All posts

MLIR学习笔记

MLIR — Running and Testing a Lowering

func.func @main(%arg0: i32) -> i32 {
  %0 = math.ctlz %arg0 : i32
  func.return %0 : i32
}

math是一个dialect,ctlz是方言math的operation

ctlz的语法由dialect 定义的parser所定义,operation的定义都有一个固定的模板。

The rest of the syntax of the operation is determined by a parser defined by the dialect, and so many operations will have different syntaxes, though many are pulled from a fixed set of options we’ll see later in the series.

block :块内的代码是顺序执行的,没有分支或跳转指令(goto,break,continue)会将控制流引入或带出块的中间部分。例如if分支的条件跳转改变了控制流,编译器可能会将这个if语句分成两个基本块。

region是一组基本块的集合,通常用于表示程序中的控制流结构,如循环或条件语句。每个区域可以包含一个或多个基本块,这些块按照特定的顺序执行。

MLIR — Writing Our First Pass

项目文件结构

代码库的结构在这里是一个相当挑剔的问题。一个典型的MLIR代码库似乎将代码分成两个目录,这两个目录具有大致相等的层级结构:一个include/目录用于存放头文件和tablegen文件,以及一个lib/目录用于存放实现代码。然后,在这两个目录中,项目会有Transform/子目录,用于存储在某个方言内部转换代码的传递文件,Conversion/用于存放转换不同方言之间的传递,Analysis/用于存放分析传递等。这些目录中的每一个可能都有子目录,用于它们操作的具体方言。这个教程将include/和lib/合在一起没做区分:

.
├── README.md
├── WORKSPACE
├── bazel
│   └──  . . .
├── lib
│   └── Transform
│       └── Affine
│           ├── AffineFullUnroll.cpp
│           ├── AffineFullUnroll.h
│           └── BUILD
├── tests
│   └── . . .
└── tools
    ├── BUILD
    └── tutorial-opt.cpp
func.func @sum_buffer(%buffer: memref<4xi32>) -> (i32) {
  %sum_0 = arith.constant 0 : i32
  %sum = affine.for %i = 0 to 4 iter_args(%sum_iter = %sum_0) -> i32 {
    %t = affine.load %buffer[%i] : memref<4xi32> 
    # 在每次迭代中,从%buffer中加载索引%i处的元素
    %sum_next = arith.addi %sum_iter, %t : i32
    affine.yield %sum_next : i32
  }
  return %sum : i32
}
  • memref<4xi32> 包含4个32位整数的内存引用

  • affine.yield %sum_next : i32表示将%sum_next传递给%sum_iter作为下一次迭代的参数

实现pass的方式之一是用C++定义:

主要方法是在OperationPass基类中定义需要的pass函数,定义的pass函数会将对应的操作(优化)锚定(anchor)在特定的上下文中。

// lib/Transform/Affine/AffineFullUnroll.h
class AffineFullUnrollPass
    : public PassWrapper<AffineFullUnrollPass,
                         OperationPass<mlir::func::FuncOp>> {
private:
  void runOnOperation() override;  // implemented in AffineFullUnroll.cpp

  StringRef getArgument() const final { return "affine-full-unroll"; }

  StringRef getDescription() const final {
    return "Fully unroll all affine loops";
  }
};
  • runOnOperation: 定义pass逻辑
  • getArgument: the CLI argument for an mlir-opt-like tool.传入命令行参数
  • getDescription: the CLI description when running --help on the mlir-opt-like tool.
// tools/tutorial-opt.cpp
#include "lib/Transform/Affine/AffineFullUnroll.h"//自定义完全展开仿射循环
#include "mlir/include/mlir/InitAllDialects.h"//提供了注册所有 MLIR 方言(dialects)的功能
#include "mlir/include/mlir/Pass/PassManager.h"
//提供了传递管理器(pass manager)的定义。传递管理器用于管理和执行一系列的传递。
#include "mlir/include/mlir/Pass/PassRegistry.h"
//提供了传递注册表(pass registry)的定义。传递注册表用于注册和查找传递
#include "mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h"
//提供了 MlirOptMain 函数的定义。MlirOptMain 是一个主函数,用于处理命令行参数并运行 MLIR 优化工具。

int main(int argc, char **argv) {
  mlir::DialectRegistry registry;
//创建一个 mlir::DialectRegistry 对象 registry。DialectRegistry 用于注册和管理 MLIR 方言
  mlir::registerAllDialects(registry);
//调用 mlir::registerAllDialects 函数,将所有已知的 MLIR 方言注册到 registry 中
  mlir::PassRegistration<mlir::tutorial::AffineFullUnrollPass>();
//注册自定义的传递 mlir::tutorial::AffineFullUnrollPass。PassRegistration 模板类用于自动注册传递,使得传递可以在传递管理器中被找到和使用

  return mlir::asMainReturnCode(
      mlir::MlirOptMain(argc, argv, "Tutorial Pass Driver", registry));
 //调用 mlir::MlirOptMain 函数,传入命令行参数、程序名称和方言注册表 registry。MlirOptMain 函数会解析命令行参数,加载 MLIR 模块,并应用指定的传递。
//mlir::asMainReturnCode 函数将 MlirOptMain 的返回值转换为适当的退出码,以便 main 函数返回给操作系统
}

定义AffineFullUnrollPass的runOnOperation方法,上面说了runOnOperation是一个pass的运行逻辑(logic):

void AffineFullUnrollPass::runOnOperation() {
  getOperation().walk([&](AffineForOp op) {
    if (failed(loopUnrollFull(op))) {
      op.emitError("unrolling failed");
      signalPassFailure();
    }
  });
}

模式重写引擎(pattern rewrite engine)代码看不懂先放着

Pattern Rewrite Engine

上述方法是通过遍历AST对AffineForOp应用loopUnrollFull()来实现循环展开。但MLIR中还可以通过模式重写引擎进行循环展开。

重写模式(rewrite pattern)是OpRewritePattern的一个子类,它有一个名为matchAndRewrite的方法,该方法执行实际的转换操作。这意味着,当模式与IR中的某个结构匹配时,matchAndRewrite方法会被调用,以应用定义的转换。这种方法的好处是它可以自动处理多次应用相同转换的情况,并且开发者不需要编写大量的代码来手动遍历AST。

↑ 不懂为什么相较于遍历AST,模式重写不需要编写大量代码来手动遍历AST。

struct AffineFullUnrollPattern ://定义模式AffineFullUnrollPattern,继承自OpRewritePattern,处理AffineForOp
  public OpRewritePattern<AffineForOp> {
  AffineFullUnrollPattern(mlir::MLIRContext *context)
      : OpRewritePattern<AffineForOp>(context, /*benefit=*/1) {}
      //benefit表示模式优先级

  LogicalResult matchAndRewrite(AffineForOp op,//匹配与重写:op与rewriter匹配时,调用loopUnrollFull展开循环
                                PatternRewriter &rewriter) const override {
    return loopUnrollFull(op);
  }
};

// A pass that invokes the pattern rewrite engine.
void AffineFullUnrollPassAsPatternRewrite::runOnOperation() {//定义runOnOperation
  mlir::RewritePatternSet patterns(&getContext());
  patterns.add<AffineFullUnrollPattern>(&getContext());//patterns添加模式AffineFullUnrollPattern
  // One could use GreedyRewriteConfig here to slightly tweak the behavior of
  // the pattern application.
  (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));//应用模式
}

A proper greedy RewritePattern

出于乘法比加法更慢且在硬件上更贵,于是设计一个模式重写,将乘法分解成加法,例如将y = 9 * x转换成a = x+x; b = a+a; c = b+b; y = c+x

  • PowerOfTwoExpand : rewrites y=C*x as y = C/2*x + C/2*x
  • PeelFromMul : 从不是2的幂的乘积中提取出一个加法,例如y = 9*x -> y = 8*x + x

PowerOfTwoExpand :

LogicalResult matchAndRewrite(
       MulIOp op, PatternRewriter &rewriter) const override {
    Value lhs = op.getOperand(0);

    // canonicalization patterns ensure the constant is on the right, if there is a constant
    // See https://mlir.llvm.org/docs/Canonicalization/#globally-applied-rules
    Value rhs = op.getOperand(1);
    auto rhsDefiningOp = rhs.getDefiningOp<arith::ConstantIntOp>();
    //获取 rhs 操作数的定义操作,并检查它是否是一个 arith::ConstantIntOp,如果不是,rhsDefiningOp = nullptr
   
    if (!rhsDefiningOp) {//rhs不是一个常数,报错
      return failure();
    }

    int64_t value = rhsDefiningOp.value();//得到rhs的值
    bool is_power_of_two = (value & (value - 1)) == 0;//判断value是否为2的幂

    if (!is_power_of_two) {
      return failure();
    }

    ConstantOp newConstant = rewriter.create<ConstantOp>(
        rhsDefiningOp.getLoc(), rewriter.getIntegerAttr(rhs.getType(), value / 2));
    //重写、新建一个常量ConstantOp ; rhsDefiningOp.getLoc()获得位置信息
    //rewriter.getIntegerAttr(rhs.getType(), value / 2)创建一个整数类型,其类型与rhs一致,值为value / 2
    
    MulIOp newMul = rewriter.create<MulIOp>(op.getLoc(), lhs, newConstant);
    AddIOp newAdd = rewriter.create<AddIOp>(op.getLoc(), newMul, newMul);
    //新建乘法、加法

    rewriter.replaceOp(op, {newAdd});//newAdd替换op
    rewriter.eraseOp(rhsDefiningOp);

    return success();
  }

PeelFromMul

LogicalResult matchAndRewrite(MulIOp op,
                                PatternRewriter &rewriter) const override {
    Value lhs = op.getOperand(0);
    Value rhs = op.getOperand(1);
    auto rhsDefiningOp = rhs.getDefiningOp<arith::ConstantIntOp>();
    if (!rhsDefiningOp) { return failure(); }
    int64_t value = rhsDefiningOp.value();

    // We are guaranteed `value` is not a power of two, because the greedy
    // rewrite engine ensures the PowerOfTwoExpand pattern is run first, since
    // it has higher benefit.

    ConstantOp newConstant = rewriter.create<ConstantOp>(
        rhsDefiningOp.getLoc(), rewriter.getIntegerAttr(rhs.getType(), value - 1));
    MulIOp newMul = rewriter.create<MulIOp>(op.getLoc(), lhs, newConstant);
    AddIOp newAdd = rewriter.create<AddIOp>(op.getLoc(), newMul, lhs);

    rewriter.replaceOp(op, {newAdd});
    rewriter.eraseOp(rhsDefiningOp);

MLIR — Using Tablegen for Passes

好家伙,一上来就跟我说,写pass一般不像上一章用C++调Api来实现,而是用tablegen。感情我白看了,而且模式重写引擎的代码也不是很好懂。

def AffineFullUnroll : Pass<"affine-full-unroll"> {
  let summary = "Fully unroll all affine loops";
  let description = [{
    Fully unroll all affine loops. (could add more docs here like code examples)
  }];
  let dependentDialects = ["mlir::affine::AffineDialect"];
}
  • tablegen以def关键字开头。需要注意的是:def与class在tablegen中是不同的。def表明接下来的代码是要被tablegen生成实际的代码;而class定义的是一个非被实例的模板,不会被tablegen生成对应代码,允许在多处实例化与重用。简而言之,def 是用于生成代码的,而 class 是用于定义模板和重用代码的。

  • 使用tablegen生成的Passes.h.inc见gist link 生成的C++代码风格都是#ifdef……#endif,即用宏为参数,#include为函数组织起来的(this pattern of using #include as a function with #define as the argument)

  • 所以在AffineFullUnroll.h和AffineFullUnrollPatternRewrite.h中,通过声明宏GEN_PASS_DECL_AFFINEFULLUNROLL GEN_PASS_DECL_AFFINEFULLUNROLLPATTERNREWRITE来开启这两个Pass的定义(定义了这两个宏,#include Passes.h.inc中就可以将这两个Pass的定义include进来。见(见gist link Line14,87)。

  • 在Passes.h中定义GEN_PASS_REGISTRATION来开启所有Pass(包括以上两个Pass)的注册。见gist link Line155,在Passes.h中定义了GEN_PASS_REGISTRATION,那么#include Passes.h.inc中就会创建registerAffineFullUnroll、registerAffineFullUnrollPatternRewrite.

  • 综上,lib/Transform/Affine文件夹层次结构就很清楚了:Passes.td中定义了 AffineFullUnroll AffineFullUnrollPatternRewrite这两个Pass , 生成的build/lib/Tranform/Affine/Passes.h.inc中包含了这两个Pass的定义和注册。AffineFullUnroll.h中通过定义宏GEN_PASS_DECL_AFFINEFULLUNROLL,在#include Passes.h.inc中引入了AffineFullUnroll的定义和注册。AffineFullUnrollPatternRewrite.h同理。

    现在AffineFullUnroll.h和AffineFullUnrollPatternRewrite.h中包含了这两个Pass的定义与注册。 Pass.h中#include进了这两个文件:

    #include "lib/Transform/Affine/AffineFullUnroll.h"
    #include "lib/Transform/Affine/AffineFullUnrollPatternRewrite.h"

    然后定义宏GEN_PASS_REGISTRATION,开启了这两个Pass的注册。

  • 生成的Passes.h.inc中定义了前面提到的一个Pass所需要定义的getArgument、getDescription()函数,但缺少函数RunOnOperation的定义(即Pass logic的定义)

    • 好吧,上面的说法有些偏差:Passes.h.inc中并没有AffineFullUnroll的定义,而是定义了AffineFullUnrollBase。AffineFullUnroll的定义在AffineFullUnroll.cpp中通过继承AffineFullUnrollBase来定义结构体AffineFullUnroll (AffineFullUnrollPatternRewrite同理)。AffineFullUnroll的定义和runOnOperation都在AffineFullUnroll.cpp中实现:
struct AffineFullUnroll : impl::AffineFullUnrollBase<AffineFullUnroll> {
  using AffineFullUnrollBase::AffineFullUnrollBase;//使用AffineFullUnrollBase的构造函数

  void runOnOperation() {
    getOperation()->walk([&](AffineForOp op) {
      if (failed(loopUnrollFull(op))) {
        op.emitError("unrolling failed");
        signalPassFailure();
      }
    });
  }
};

MLIR — Defining a New Dialect

dialect使用tablegen定义:PolyDialect.td:

include "mlir/IR/DialectBase.td"

def Poly_Dialect : Dialect {
  let name = "poly";
  let summary = "A dialect for polynomial math";
  let description = [{
    The poly dialect defines types and operations for single-variable
    polynomials over integers.
  }];

let cppNamespace = "::mlir::tutorial::poly";
}

dialect定义的方式与pass差不多,但基于PolyOps.td文件生成了多个目标文件,见cmakelist:

set(LLVM_TARGET_DEFINITIONS PolyOps.td)
mlir_tablegen(PolyOps.h.inc -gen-op-decls)
mlir_tablegen(PolyOps.cpp.inc -gen-op-defs)
mlir_tablegen(PolyTypes.h.inc -gen-typedef-decls -typedefs-dialect=poly)
mlir_tablegen(PolyTypes.cpp.inc -gen-typedef-defs -typedefs-dialect=poly)
mlir_tablegen(PolyDialect.h.inc -gen-dialect-decls -dialect=poly)
mlir_tablegen(PolyDialect.cpp.inc -gen-dialect-defs -dialect=poly)

此外,dialect也需要在tutorial-opt.cpp中额外注册:

mlir::DialectRegistry registry;
registry.insert<mlir::tutorial::poly::PolyDialect>();
mlir::registerAllDialects(registry);

一种方言的文件组织形式(以poly方言为例):

  • PolyTypes.h只包含PolyTypes.h.inc

  • 在 PolyDialect.cpp 中包含 PolyTypes.cpp.inc

  • 添加 PolyTypes.cpp:如果需要,应该添加一个 PolyTypes.cpp 文件,这个文件包含了一些额外的实现,这些实现是 tablegen(一个代码生成工具)声明的,但是不能自动生成的函数。(项目文件中并没有该文件,但在PolyOps.cpp中实现了一些不能自动生成的逻辑。)

  • 总之,每一个.h文件对应一个.h.inc,每一个.cpp对应.cpp.inc,并且在PolyDialect.cpp中将它们连接起来。

以上定义的poly方言是空的,接下来为它加一些内容:

添加一个poly type

// PolyTypes.td
#ifndef LIB_DIALECT_POLY_POLYTYPES_TD_
#define LIB_DIALECT_POLY_POLYTYPES_TD_

include "PolyDialect.td"
include "mlir/IR/AttrTypeBase.td"

// A base class for all types in this dialect
class Poly_Type<string name, string typeMnemonic> : TypeDef<Poly_Dialect, name> {
  let mnemonic = typeMnemonic;
}

def Polynomial : Poly_Type<"Polynomial", "poly"> {
  let summary = "A polynomial with u32 coefficients";

  let description = [{
    A type for polynomials with integer coefficients in a single-variable polynomial ring.
  }];
  //单变量多项式

  let parameters = (ins "int":$degreeBound);//输入参数是$degreeBound,类型是int,表示多项式的最高次数
  let assemblyFormat = "`<` $degreeBound `>`";
}

#endif  // LIB_DIALECT_POLY_POLYTYPES_TD_

添加操作(Operations)

class Poly_BinOp<string mnemonic> : Op<Poly_Dialect, mnemonic, [Pure, ElementwiseMappable, SameOperandsAndResultType]> {
  //                                  ↑属于Poly_Dialect方言,助记符,pure表示操作无副作用?,
  //              ElementwiseMappable表示可以逐元素操作,SameOperandsAndResultType表示操作数和结果类型相同
  let arguments = (ins PolyOrContainer:$lhs, PolyOrContainer:$rhs);
  //        接受两个输入参数,类型为PolyOrContainer,名称为lhs和rhs
  let results = (outs PolyOrContainer:$output);
  let assemblyFormat = "$lhs `,` $rhs attr-dict `:` qualified(type($output))";
  //例如 :%result = poly.add %lhs, %rhs, {attributeName = attributeValue} : poly-or-container
  let hasCanonicalizer = 1;//支持规范化,即支持特定规则对多项式进行简化
  let hasFolder = 1;//支持合并(折叠)优化
  let hasCanonicalizer = 1;//支持规范化,即支持特定规则对多项式进行简化
}

def Poly_AddOp : Poly_BinOp<"add"> {
  let summary = "Addition operation between polynomials.";
}

def Poly_SubOp : Poly_BinOp<"sub"> {
  let summary = "Subtraction operation between polynomials.";
}

def Poly_MulOp : Poly_BinOp<"mul"> {
  let summary = "Multiplication operation between polynomials.";
}

MLIR — Using Traits

  • traits and interfaces(特性与接口)

interfaces好理解,就是将一系列方法、属性封装成类,基于派生、继承、多态等手段,调用抽象的接口。

traits是将类型关联起来,从而实现类型特征的抽象。例如C++中的template

好吧,mlir语境下,traits是指用来描述和约束操作(操作是 MLIR 的基本构建块之一)的特性和行为的特性或属性集。相比于传统的 C++ 或其他编程语言中,MLIR 的 traits 主要用于在编译器级别进行优化和生成代码时提供特定的语义信息。例如pure表示操作时无副作用的,ConstantLike表示该操作的输出可视为常量。

Traits and Loop Invariant Code Motion(循环不变量外提)

循环不变量外提是mlir提供的一个pass,用于将循环中的不变量指令移动到循环外计算,从而减少无效指令的运行。但并不是所有含不变量的指令都能够外提,外提需要满足两个条件:①指令是NoMemoryEffect,也就是说,指令不对写内存产生影响。(the operation does not have any side effects related to writing to memory) ② AlwaysSpeculatable 指令可以被编译器推断执行。

MLIR提供了一个Trait叫Pure,它包含了NoMemoryEffect和AlwaysSpeculatable,我们可以直接给类型的模板(class)添加这个trait:

class Poly_BinOp<string mnemonic> : Op<Poly_Dialect, mnemonic, [Pure]> {

添加完这些Trait后,tablegen生成的文件中也增加了以下内容

// PolyOps.h.inc
class SubOp : public ::mlir::Op<SubOp,
::mlir::OpTrait::ZeroRegions,
::mlir::OpTrait::OneResult,
::mlir::OpTrait::OneTypedResult<::mlir::tutorial::poly::PolynomialType>::Impl,
::mlir::OpTrait::ZeroSuccessors,
::mlir::OpTrait::NOperands<2>::Impl,
::mlir::OpTrait::OpInvariants,
::mlir::ConditionallySpeculatable::Trait,            // <-- new
::mlir::OpTrait::AlwaysSpeculatableImplTrait,   // <-- new
::mlir::MemoryEffectOpInterface::Trait>          // <--- new
{ ... }
// PolyOps.h.inc
void SubOp::getEffects(
  ::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
}

接下来就是讲了一些Traits , 例如:ElementwiseMappable、SameOperandsAndResultElementType、Involution、Idempotent等,这里没抄了。

MLIR — Folders and Constant Propagation

Constant Propagation vs Canonicalization

常量传播(Constant Propagation):当程序中,一个变量(或一个operation)的返回/输出总是一个常量时,可以在之后的程序中用常量替代变量,从而减少编译计算。

规范化(canonicalize)也能进行常量折叠,甚至删除死代码(Constant Propagation不会删除)。

以下是一个例子:

//  tests/scc[p.mlir
func.func @test_arith_sccp() -> i32 {
  %0 = arith.constant 7 : i32
  %1 = arith.constant 8 : i32
  %2 = arith.addi %0, %0 : i32
  %3 = arith.muli %0, %0 : i32
  %4 = arith.addi %2, %3 : i32
  return %2 : i32
}

tutorial-opt —sccp sccp.mlir

func.func @test_arith_sccp() -> i32 {
  %c63_i32 = arith.constant 63 : i32
  %c49_i32 = arith.constant 49 : i32
  %c14_i32 = arith.constant 14 : i32
  %c8_i32 = arith.constant 8 : i32
  %c7_i32 = arith.constant 7 : i32
  return %c14_i32 : i32
}

tutorial-opt —canonicalize sccp.mlir

func.func @test_arith_sccp() -> i32 {
  %c14_i32 = arith.constant 14 : i32
  return %c14_i32 : i32
}

--sccp和--canonicalize都是通过folding实现的。

为了支持Folding操作,我们需要完善:

  • 完善constant operation
  • 添加materialization hook
  • 为每个operation添加folder

constant operation

之前我们声明一个poly.poly类型的量,需要这样两步SSA声明:

%0 = arith.constant dense<[1, 2, 3]> : tensor<3xi32>
%p0 = poly.from_tensor %0 : tensor<3xi32> -> !poly.poly<10>

现在我们想要简化成:

%0 = poly.constant dense<[2, 8, 20, 24, 18]> : !poly.poly<10>

给constant operation添加ConstantLike trait , 修改arguments和assemblyFormat :

def Poly_ConstantOp : Op<Poly_Dialect, "constant", [Pure, ConstantLike]> {   // new
  let summary = "Define a constant polynomial via an attribute.";
  let arguments = (ins AnyIntElementsAttr:$coefficients);    // new
  let results = (outs Polynomial:$output);
  let assemblyFormat = "$coefficients attr-dict `:` type($output)";//new
}

Adding folder

let hasFolder = 1;

并在PolyOps.cpp中定义各Operaion的::fold函数

MLIR — Verifiers

Trait-based Verifiers

这类verifies有着traits一样的格式,都是定义在operation的定义参数内。

例如Poly_BinOp的SameOperandsAndResultType,它会去验证(推断)输入输出类型是否相同。以下是Poly_BinOp的前后变化

- class Poly_BinOp<string mnemonic> : Op<Poly_Dialect, mnemonic, [Pure, ElementwiseMappable]> {
+ class Poly_BinOp<string mnemonic> : Op<Poly_Dialect, mnemonic, [Pure, ElementwiseMappable, SameOperandsAndResultType]> {
  let arguments = (ins PolyOrContainer:$lhs, PolyOrContainer:$rhs);
  let results = (outs PolyOrContainer:$output);
- let assemblyFormat = "$lhs `,` $rhs attr-dict `:` `(` qualified(type($lhs)) `,` qualified(type($rhs)) `)` `->` qualified(type($output))";
+ let assemblyFormat = "$lhs `,` $rhs attr-dict `:` qualified(type($output))";#无需指明输入的类型
  let hasFolder = 1;
}

对于操作Poly_EvalOp,输入输出一定是不同的,可以使用Verifies AllTypesMatch:

def Poly_EvalOp : Op<Poly_Dialect, "eval", [AllTypesMatch<["point", "output"]>]> {
  let summary = "Evaluates a Polynomial at a given input value.";
  let arguments = (ins Polynomial:$input, AnyInteger:$point);
  let results = (outs AnyInteger:$output);
  let assemblyFormat = "$input `,` $point attr-dict `:` `(` qualified(type($input)) `,` type($point) `)` `->` type($output)";
}

A custom verifier

我们可以自己定义verifier

// PolyOps.td
// Inject verification that all integer-like arguments are 32-bits
def Has32BitArguments : NativeOpTrait<"Has32BitArguments"> {
  let cppNamespace = "::mlir::tutorial::poly";
}

然后在PolyTraits.h中实现Has32BitArguments

template <typename ConcreteType>
class Has32BitArguments : public OpTrait::TraitBase<ConcreteType, Has32BitArguments> {
 public:
  static LogicalResult verifyTrait(Operation *op) {
    for (auto type : op->getOperandTypes()) {
      // OK to skip non-integer operand types
      if (!type.isIntOrIndex()) continue;

      if (!type.isInteger(32)) {
        return op->emitOpError()
               << "requires each numeric operand to be a 32-bit integer";
      }
    }

    return success();
  }
};

MLIR — Canonicalizers and Declarative Rewrite Patterns

待看,先去看mlir toy tutorial了

Chapter 1: Toy Language and AST

第一章做了Toy语言的词法分析、语法分析并生成了AST。

Lexer.h文件定义了Lexer类,用于遍历代码字符串,返回各个词的词法。

AST.h定义各个语法树结点,例如NumberExprAST、LiteralExprAST

Parser.h解析代码字符串,根据词法,实例化语法树结点。

Chapter 2: Esmitting Basic MLIR

第二章讲的主要是Dialect的定义,这些都在mlir-tutorial详尽地描述过,此处不赘述。

我更关心mlir-generator,它在Dialect.cpp和MLIRGen.cpp中实现,但第二章没做任何讲述。

值得注意的是,第二章的Dialect.cpp中对操作定义了多个函数,例如AddOp::build、AddOp::parse、AddOp::print,这些在mlir-tutorial-j2kun中没有提到,重点来看这些内容。

Operation::build

Operation的build方法可以在tablegen中定义并自动生成:

MLIRGEN.cpp中的builder.create()隐式调用了operation::build()方法

dump()方法隐式调用了Operation::print() , Operation::parse()用于解析Mlir输入

如果在Ops.td中定义了Operations的assemblyFormat,那么Ops.cpp.inc会自动生成该操作的print和parse方法,而无需在Dialect.cpp中定义。

mlir好多源代码都是用tablegen生成的(.inc文件)

Chapter 4 Enabling Generic Transformation with Interfaces

==疑问==:没有找到CastOp匹配generic_call与callee的类型的逻辑代码。

第三章介绍了模式匹配与重写,它需要给每一个操作定义模式重写的逻辑。当需要模式重写的操作有许多时,代码就会变得冗余。MLIR引入了Interface来解决这一问题,简单而言,如果多个操作具有相似的模式重写逻辑,那么就可以定义通用的Interface实现,再将这一个Interface应用于多个Operations即可。

Inlining

对于大多数函数而言,内联这一模式重写的逻辑是相似或一致的

相关资料

HCL-Dialect作者写的介绍,放在cs6120的官网上

知乎文章解析Mlir toy tutorial

这个人的知乎有mlir教程的翻译

nelli: A lightweight frontend for MLIR (arxiv.org)

知乎一个学习路线

在mlir toy tutorial的基础上添加MatMul Operation教程

一个人的llvm学习笔记