[mlir][TOSA] Set default TOSA validation level to 'None' for TOSA -> linalg

[benmxwl-arm]

Summary

Unless otherwise specified this pass should not assume a level, as this
rejects otherwise valid TOSA. This has caused build failures in IREE.

The level (and other validation options) have now been made configurable.

The pass options have been converted to enums to make them more type
safe in C++.

[Tai78641]

lgtm

[mamrami]

Can you add tests that show the change?
Thanks!

[benmxwl-arm]

In D157282#4569734, @mamrami wrote:

Can you add tests that show the change?
Thanks!

Hey, for the purposes of LLVM this is a non-functional change.
It just now allows passing ValidationOptions to tosa::addTosaToLinalgPasses() (with a default of none picked to match IREE's expectations), this is an API that's used in IREE, though not LLVM itself.

This was due to D154273 which added these level checks, which now needed some option for configuration.

So, unfortunately, I can't think of an easy little test case to add here, though I'm welcome to suggestions :)

[mamrami]

Thanks! Now that I understand the change, I see why there are no tests.

If we could run addTosaToLinalgPasses pipeline using mlir-opt, I believe you could add a lit test that fails without your change.
But I see that we don't use PassPipelineRegistration on addTosaToLinalgPasses so we can't run the pipeline from mlir-opt.

@amirBish is going to upload a patch that combines addTosaToLinalgPasses parameters to TosaToLinalgOptions.
Once this is done, we can use PassPipelineRegistration and create lit tests for the pipeline.

Meanwhile I agree that there's no simple test that can be added.

mlir/include/mlir/Conversion/TosaToLinalg/TosaToLinalg.h

 //===-- TosaToLinalg.h - TOSA optimization pass declarations ----------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the passes for the TOSA Linalg Dialect in MLIR.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_TOSATOLINALG_TOSATOLINALG_H
 #define MLIR_CONVERSION_TOSATOLINALG_TOSATOLINALG_H
 
+#include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 #define GEN_PASS_DECL_TOSATOLINALG
 #define GEN_PASS_DECL_TOSATOLINALGNAMED
 #include "mlir/Conversion/Passes.h.inc"
 
 namespace tosa {
 
 std::unique_ptr<Pass> createTosaToLinalg();
 std::unique_ptr<Pass> createTosaToLinalgNamed();
 
 /// Populates passes to convert from TOSA to Linalg on buffers. At the end of
 /// the pass, the function will only contain linalg ops or standard ops if the
 /// pipeline succeeds.  The option to disable decompositions is available for
 /// benchmarking performance improvements from the canonicalizations.
-void addTosaToLinalgPasses(OpPassManager &pm,
-                           bool disableTosaDecompositions = false);
+void addTosaToLinalgPasses(
+    OpPassManager &pm, bool disableTosaDecompositions = false,
+    // Note: Default to 'none' level unless otherwise specified.
+    tosa::ValidationOptions const &validationOptions =
+        tosa::ValidationOptions().setLevel(tosa::TosaLevelEnum::None));
 
 /// Populates conversion passes from TOSA dialect to Linalg dialect.
 void populateTosaToLinalgConversionPatterns(RewritePatternSet *patterns);
 
 /// Populates conversion passes from TOSA dialect to Linalg named operations.
 void populateTosaToLinalgNamedConversionPatterns(RewritePatternSet *patterns);
 
 } // namespace tosa
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_TOSATOLINALG_TOSATOLINALG_H

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

 void populateTosaFoldConstantTransposePatterns(MLIRContext *ctx,
                                                RewritePatternSet &patterns);
 
 std::unique_ptr<Pass> createTosaLayerwiseConstantFoldPass();
 std::unique_ptr<Pass> createTosaInferShapesPass();
 std::unique_ptr<Pass> createTosaMakeBroadcastablePass();
 std::unique_ptr<Pass> createTosaTestQuantUtilAPIPass();
 std::unique_ptr<Pass> createTosaOptionalDecompositions();
-std::unique_ptr<Pass> createTosaValidationPass();
+
+struct ValidationOptions {
+  /// Validate if operations match for the given profile.
+  TosaProfileEnum profile = TosaProfileEnum::Undefined;
+  ValidationOptions &setProfile(TosaProfileEnum profile) {
+    this->profile = profile;
+    return *this;
+  }
+  /// Verify if the properties of certain operations align the spec requirement.
+  bool strictOperationSpecAlignment = false;
+  ValidationOptions &enableStrictOperationSpecAlignment(bool enable = true) {
+    strictOperationSpecAlignment = enable;
+    return *this;
+  }
+  /// Validate if operator parameters are within specfication for the given
+  /// level.
+  TosaLevelEnum level = TosaLevelEnum::EightK;
+  ValidationOptions &setLevel(TosaLevelEnum level) {
+    this->level = level;
+    return *this;
+  }
+};
+
+std::unique_ptr<Pass> createTosaValidationPass(
+    ValidationOptions const &options = ValidationOptions());
 
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
 
 } // namespace tosa
 } // namespace mlir
 
 #endif // MLIR_DIALECT_TOSA_TRANSFORMS_PASSES_H

mlir/include/mlir/Dialect/Tosa/Transforms/Passes.td

def TosaValidation : Pass<"tosa-validate", "func::FuncOp"> {
   let summary = "Validates TOSA dialect";
   let description = [{
     This pass validates if input TOSA operations match the specification for given
     criteria, e.g. TOSA profile.
   }];
   let constructor = "createTosaValidationPass()";
 
   let options = [
-      Option<"profileName", "profile", "std::string",
-             /*default=*/"\"undefined\"",
-             "Validate if operations match for the given profile">,
+      Option<"profile", "profile", "mlir::tosa::TosaProfileEnum",
+             /*default=*/"mlir::tosa::TosaProfileEnum::Undefined",
+             "Validate if operations match for the given profile",
+             [{::llvm::cl::values(
+               clEnumValN(mlir::tosa::TosaProfileEnum::BaseInference, "bi",
+                "Use Base Inference profile."),
+               clEnumValN(mlir::tosa::TosaProfileEnum::MainInference, "mi",
+                "Use Main Inference profile."),
+               clEnumValN(mlir::tosa::TosaProfileEnum::MainTraining, "mt",
+                "Use Main Training profile."),
+               clEnumValN(mlir::tosa::TosaProfileEnum::MainTraining, "undefined",
+                "Do not define a profile.")
+              )}]>,
       Option<"StrictOperationSpecAlignment", "strict-op-spec-alignment", "bool",
              /*default=*/"false",
              "Verify if the properties of certain operations align the spec requirement">,
-      Option<"levelName", "level", "std::string",
-             /*default=*/"\"8k\"",
-             "Validate if operator parameters are within specfication for the given level">,
+      Option<"level", "level", "mlir::tosa::TosaLevelEnum",
+             /*default=*/"mlir::tosa::TosaLevelEnum::EightK",
+             "Validate if operator parameters are within specfication for the given level",
+             [{::llvm::cl::values(
+               clEnumValN(mlir::tosa::TosaLevelEnum::EightK, "8k",
+                "Ranges are expected to be sufficient for applications with frame sizes up to 8K."),
+               clEnumValN(mlir::tosa::TosaLevelEnum::None, "none",
+                "Allows the full range of arguments specified by the operations according "
+                "to the operation data types.")
+              )}]>
    ];
 }
 
 #endif // MLIR_DIALECT_TOSA_TRANSFORMS_PASSES

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgPass.cpp

public:
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::tosa::createTosaToLinalg() {
   return std::make_unique<TosaToLinalg>();
 }
 
-void mlir::tosa::addTosaToLinalgPasses(OpPassManager &pm,
-                                       bool disableTosaDecompositions) {
+void mlir::tosa::addTosaToLinalgPasses(
+    OpPassManager &pm, bool disableTosaDecompositions,
+    tosa::ValidationOptions const &validationOptions) {
   // Optional decompositions are designed to benefit linalg.
   if (!disableTosaDecompositions)
     pm.addNestedPass<func::FuncOp>(tosa::createTosaOptionalDecompositions());
   pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
 
   pm.addNestedPass<func::FuncOp>(tosa::createTosaInferShapesPass());
   pm.addNestedPass<func::FuncOp>(tosa::createTosaMakeBroadcastablePass());
   pm.addNestedPass<func::FuncOp>(tosa::createTosaToLinalgNamed());
   pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
   // TODO: Remove pass that operates on const tensor and enable optionality
   pm.addNestedPass<func::FuncOp>(tosa::createTosaLayerwiseConstantFoldPass());
   pm.addNestedPass<func::FuncOp>(tosa::createTosaMakeBroadcastablePass());
-  pm.addNestedPass<func::FuncOp>(tosa::createTosaValidationPass());
+  pm.addNestedPass<func::FuncOp>(
+      tosa::createTosaValidationPass(validationOptions));
   pm.addNestedPass<func::FuncOp>(tosa::createTosaToLinalg());
 }

mlir/lib/Dialect/Tosa/Transforms/TosaValidation.cpp

 
 //===----------------------------------------------------------------------===//
 // TOSA Validation Pass.
 //===----------------------------------------------------------------------===//
 
 struct TosaValidation : public tosa::impl::TosaValidationBase<TosaValidation> {
 public:
   explicit TosaValidation() { populateConstantOperandChecks(); }
+  explicit TosaValidation(const ValidationOptions &options) : TosaValidation() {
+    this->profile = options.profile;
+    this->StrictOperationSpecAlignment = options.strictOperationSpecAlignment;
+    this->level = options.level;
+  }
   void runOnOperation() override;
 
   LogicalResult applyConstantOperandCheck(Operation *op) {
     for (auto &checker : const_checkers) {
       if (failed(checker(op)))
         return failure();
     }
     return success();
if (auto resize = dyn_cast<tosa::ResizeOp>(op)) {
       }
     }
     return true;
   }
 
   // configure profile and level values from pass options profileName and
   // levelName
   void configLevelAndProfile() {
-    profileType = symbolizeEnum<TosaProfileEnum>(profileName);
-
-    auto levelType = symbolizeEnum<TosaLevelEnum>(levelName);
-
     tosa_level = TOSA_LEVEL_NONE;
-    if (levelType == TosaLevelEnum::EightK) {
+    if (level == TosaLevelEnum::EightK) {
       tosa_level = TOSA_LEVEL_EIGHTK;
     }
   }
 
   SmallVector<std::function<LogicalResult(Operation *)>> const_checkers;
-  std::optional<TosaProfileEnum> profileType;
   tosa_level_t tosa_level;
 };
 
 LogicalResult TosaValidation::applyLevelCheck(Operation *op) {
   if (tosa_level == TOSA_LEVEL_NONE) {
     // no need to do level checks
     return success();
   }
LogicalResult TosaValidation::applyLevelCheck(Operation *op) {
 
   return success();
 }
 
 void TosaValidation::runOnOperation() {
   configLevelAndProfile();
   getOperation().walk([&](Operation *op) {
     for (Value operand : op->getOperands()) {
-      if ((profileType == TosaProfileEnum::BaseInference) &&
+      if ((profile == TosaProfileEnum::BaseInference) &&
           isa<FloatType>(getElementTypeOrSelf(operand))) {
         return signalPassFailure();
       }
       if (getElementTypeOrSelf(operand).isF64()) {
         return signalPassFailure();
       }
     }
 
     // Some uses of TOSA rely on the constant operands of particular operations.
     if (StrictOperationSpecAlignment && failed(applyConstantOperandCheck(op)))
       signalPassFailure();
 
     // do level checks
     if (failed(applyLevelCheck(op)))
       signalPassFailure();
   });
 }
 } // namespace
 
-std::unique_ptr<Pass> mlir::tosa::createTosaValidationPass() {
-  return std::make_unique<TosaValidation>();
+std::unique_ptr<Pass>
+mlir::tosa::createTosaValidationPass(ValidationOptions const &options) {
+  return std::make_unique<TosaValidation>(options);
 }