mlir toy 教程(1)

最新推荐文章于 2024-07-21 21:37:12 发布
最新推荐文章于 2024-07-21 21:37:12 发布
阅读量1.6k 收藏 5
点赞数 4
分类专栏： LLVM/TVM/编译理论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tengfei461807914/article/details/111878018
版权

本文翻译自MLIR 官网 TOY教程，附带个人理解与批注，内容仅用于个人学习与记录

Chapter 1: Toy Language and AST

第一章：Toy语言与AST

注：ast为抽象语法树，这里需要有编译原理的基础，至少要知道各个组件是做什么的

This tutorial will be illustrated with a toy language that we’ll call “Toy” (naming is hard…). Toy is a tensor-based language that allows you to define functions, perform some math computation, and print results.
该教程会使用一个叫做"toy"的编程语言作为示例。toy是一个tensor-based的语言，允许用户定义函数，执行一些数学计算并输出结果。

注：tensor-based顾名思义，就是一套用于张量运算的语言，张量运算在深度学习中有大量使用，MLIR的诞生就是为了优化张量运算而来的

Given that we want to keep things simple, the codegen will be limited to tensors of rank <= 2, and the only datatype in Toy is a 64-bit floating point type (aka ‘double’ in C parlance). As such, all values are implicitly double precision, Values are immutable (i.e. every operation returns a newly allocated value), and deallocation is automatically managed. But enough with the long description; nothing is better than walking through an example to get a better understanding:

为了使用于学习的示例简单易懂，codegen会限制为一个rank <=2的tensors，并且toy的数据类型只有fp64类型（c语言中的double类型）。如此一来，所有的值类型都是隐式的表示为双精度类型。
所有的值类型都是不可变的(immutable）（例如每个操作都会返回一个新申请的变量），并且变量会被自动回收。多说无益，自己动手搞一遍比啥都强。（真理）

注：codegen用中文来解释，就是代码生成的意思，也是一种开发中常用的技术手段，可以根据固定的格式生成源代码，比如caffe里面使用的哪个protobuf

看下面一段代码：

def main() {
  # Define a variable `a` with shape <2, 3>, initialized with the literal value.
  # 定义一个形状为<2,3>的变量a，并对其用字面值初始化
  # The shape is inferred from the supplied literal.
  # 变量的形状可以通过字面值推倒出来（这句不是废话，见下面）
  var a = [[1, 2, 3], [4, 5, 6]];

  # b is identical to a, the literal tensor is implicitly reshaped: defining new
  # variables is the way to reshape tensors (element count must match).
  # b和a纬度一样，不过它的形状会被隐式的推到出来。将一个tensor进行reshape操作的办法之一就是定义一个新变量（注意元素数量要匹配上）
  var b<2, 3> = [1, 2, 3, 4, 5, 6];

  # transpose() and print() are the only builtin, the following will transpose
  # transpose()与print() 操作是builtin的方法，接下来的操作会对a和b进行transpose操作，并执行一个element-wise的乘法，在打印最后的结果
  # a and b and perform a element-wise multiplication before printing the result.
  print(transpose(a) * transpose(b));
}

注：builtin中文是内建的，一般是系统提供的高性能函数或系统自带的函数文中指的是后者

AST

将上面代码的ast得到的结果dump出来，如下：

Module:
  Function 
    Proto 'multiply_transpose' @test/Examples/Toy/Ch1/ast.toy:4:1'
    Params: [a, b]
    Block {
      Return
        BinOp: * @test/Examples/Toy/Ch1/ast.toy:5:25
          Call 'transpose' [ @test/Examples/Toy/Ch1/ast.toy:5:10
            var: a @test/Examples/Toy/Ch1/ast.toy:5:20
          ]
          Call 'transpose' [ @test/Examples/Toy/Ch1/ast.toy:5:25
            var: b @test/Examples/Toy/Ch1/ast.toy:5:35
          ]
    } // Block
  Function 
    Proto 'main' @test/Examples/Toy/Ch1/ast.toy:8:1'
    Params: []
    Block {
      VarDecl a<> @test/Examples/Toy/Ch1/ast.toy:11:3
        Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @test/Examples/Toy/Ch1/ast.toy:11:11
      VarDecl b<2, 3> @test/Examples/Toy/Ch1/ast.toy:15:3
        Literal: <6>[ 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00] @test/Examples/Toy/Ch1/ast.toy:15:17
      VarDecl c<> @test/Examples/Toy/Ch1/ast.toy:19:3
        Call 'multiply_transpose' [ @test/Examples/Toy/Ch1/ast.toy:19:11
          var: a @test/Examples/Toy/Ch1/ast.toy:19:30
          var: b @test/Examples/Toy/Ch1/ast.toy:19:33
        ]
      VarDecl d<> @test/Examples/Toy/Ch1/ast.toy:22:3
        Call 'multiply_transpose' [ @test/Examples/Toy/Ch1/ast.toy:22:11
          var: b @test/Examples/Toy/Ch1/ast.toy:22:30
          var: a @test/Examples/Toy/Ch1/ast.toy:22:33
        ]
      VarDecl e<> @test/Examples/Toy/Ch1/ast.toy:25:3
        Call 'multiply_transpose' [ @test/Examples/Toy/Ch1/ast.toy:25:11
          var: b @test/Examples/Toy/Ch1/ast.toy:25:30
          var: c @test/Examples/Toy/Ch1/ast.toy:25:33
        ]
      VarDecl f<> @test/Examples/Toy/Ch1/ast.toy:28:3
        Call 'multiply_transpose' [ @test/Examples/Toy/Ch1/ast.toy:28:11
          Call 'transpose' [ @test/Examples/Toy/Ch1/ast.toy:28:30
            var: a @test/Examples/Toy/Ch1/ast.toy:28:40
          ]
          var: c @test/Examples/Toy/Ch1/ast.toy:28:44
        ]
    } // Block

注：上的抽象语法树的生成的编译命令如下：

首先进入到llvm-project/build的目录下面，这个build的目录里面已经把教程中的所有可执行程序都跑编译好了。
然后执行

bin/toyc-ch1 ../mlir/test/Examples/Toy/Ch1/ast.toy -emit=ast

会得到上面的抽象语法树内容

输出的ast，可以观察得到一个层级形式的结构。
最外为Module层，在Module层中包括两个Function层，在Function层中Proto描述了函数的名称以及所在位置；Param描述了参数信息；Block描述了函数中具体实现的内容。
在函数的内容中包括如VarDecl，Literal以及var等类型，后面再详细讨论。

其中ast.toy的内容如下：

# RUN: toyc-ch1 %s -emit=ast 2>&1 | FileCheck %s

# User defined generic function that operates on unknown shaped arguments.
def multiply_transpose(a, b) {
  return transpose(a) * transpose(b);
}

def main() {
  # Define a variable `a` with shape <2, 3>, initialized with the literal value.
  # The shape is inferred from the supplied literal.
  var a = [[1, 2, 3], [4, 5, 6]];
  # b is identical to a, the literal array is implicitly reshaped: defining new
  # variables is the way to reshape arrays (element count in literal must match
  # the size of specified shape).
  var b<2, 3> = [1, 2, 3, 4, 5, 6];

  # This call will specialize `multiply_transpose` with <2, 3> for both
  # arguments and deduce a return type of <2, 2> in initialization of `c`.
  var c = multiply_transpose(a, b);
  # A second call to `multiply_transpose` with <2, 3> for both arguments will
  # reuse the previously specialized and inferred version and return `<2, 2>`
  var d = multiply_transpose(b, a);
  # A new call with `<2, 2>` for both dimension will trigger another
  # specialization of `multiply_transpose`.
  var e = multiply_transpose(b, c);
  # Finally, calling into `multiply_transpose` with incompatible shape will
  # trigger a shape inference error.
  var f = multiply_transpose(transpose(a), c);
}


# CHECK: Module:
# CHECK-NEXT:     Function
# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1
# CHECK-NEXT:       Params: [a, b]
# CHECK-NEXT:       Block {
# CHECK-NEXT:         Return
# CHECK-NEXT:           BinOp: * @{{.*}}ast.toy:5:25
# CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:10
# CHECK-NEXT:               var: a @{{.*}}ast.toy:5:20
# CHECK-NEXT:             ]
# CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:25
# CHECK-NEXT:               var: b @{{.*}}ast.toy:5:35
# CHECK-NEXT:             ]
# CHECK-NEXT:       } // Block
# CHECK-NEXT:     Function
# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1
# CHECK-NEXT:       Params: []
# CHECK-NEXT:       Block {
# CHECK-NEXT:         VarDecl a<> @{{.*}}ast.toy:11:3
# CHECK-NEXT:           Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @{{.*}}ast.toy:11:11
# CHECK-NEXT:         VarDecl b<2, 3> @{{.*}}ast.toy:15:3
# CHECK-NEXT:           Literal: <6>[ 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00] @{{.*}}ast.toy:15:17
# CHECK-NEXT:         VarDecl c<> @{{.*}}ast.toy:19:3
# CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:19:11
# CHECK-NEXT:             var: a @{{.*}}ast.toy:19:30
# CHECK-NEXT:             var: b @{{.*}}ast.toy:19:33
# CHECK-NEXT:           ]
# CHECK-NEXT:         VarDecl d<> @{{.*}}ast.toy:22:3
# CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:22:11
# CHECK-NEXT:             var: b @{{.*}}ast.toy:22:30
# CHECK-NEXT:             var: a @{{.*}}ast.toy:22:33
# CHECK-NEXT:           ]
# CHECK-NEXT:         VarDecl e<> @{{.*}}ast.toy:25:3
# CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:25:11
# CHECK-NEXT:             var: b @{{.*}}ast.toy:25:30
# CHECK-NEXT:             var: c @{{.*}}ast.toy:25:33
# CHECK-NEXT:           ]
# CHECK-NEXT:         VarDecl f<> @{{.*}}ast.toy:28:3
# CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:28:11
# CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:28:30
# CHECK-NEXT:               var: a @{{.*}}ast.toy:28:40
# CHECK-NEXT:             ]
# CHECK-NEXT:             var: c @{{.*}}ast.toy:28:44
# CHECK-NEXT:           ]

The code for the lexer is fairly straightforward; it is all in a single header: examples/toy/Ch1/include/toy/Lexer.h. The parser can be found in examples/toy/Ch1/include/toy/Parser.h; it is a recursive descent parser. If you are not familiar with such a Lexer/Parser, these are very similar to the LLVM Kaleidoscope equivalent that are detailed in the first two chapters of the Kaleidoscope Tutorial .

代码的lexer很直观，全部都放在一个头文件里面。parser可以在对应位置找到，它是一个递归下降的parser。如果对lexer和parser不熟悉，建议你看看Kaleidoscope教程。（带货）

注：lexer是词法分析器，parser是语法分析器，都是编译原理中的基本概念，上面提到的教程是llvm提供的一个教程

【AI编译器】MLIR — 入门
AI知识搬运工
12-23 1190
MLIR 社区充满活力。但由于它是一个新的且快速发展的项目，因此可用的教程和文档并不多。没有权威的MLIR书籍。大多数围绕事物的推理都来自民间传说和技术性很强的 RFC。而且由于 MLIR 构建在 LLVM（该缩写词以前的意思是“低级虚拟机”）之上，因此现有的许多文档都通过类比 LLVM 来解释概念，这对于像我这样不熟悉内部结构的人来说没有帮助LLVM 的工作原理。最后，在我看来，目前的教程水平太高，无法让人们真正了解如何在框架中编写程序。为此，我希望降低使用 MLIR 的准入门槛。
MLIR入门：环境搭建和Toy代码分析
teng198的博客
12-20 682
DRR(Declarative Rewrite Rules)：声明性规则重写。matchAndRewrite 匹配和重写。使用PassManager添加优化工序。
20200226-MLIR Toy Tutorial概述-zhanghongbin.pdf
12-16
20200226-MLIR Toy Tutorial概述-zhanghongbin.pdf
mlir toy 教程(2)
@fei
02-11 2020
本文翻译自MLIR 官网 TOY教程，附带个人理解与批注，内容仅用于个人学习与记录 Chapter 2: Emitting Basic MLIR Introduction: Multi-Level Intermediate Representation 多级中间表示 Other compilers, like LLVM (see the Kaleidoscope tutorial ), offer a fixed set of predefined types and (usually low-level
MLIR的TOY教程学习笔记
性感的小君君
07-21 1220
MLIR 中，每一个operation都与代码位置强相关，不像LLVM，可以随意删除。MLIR可以自定义IR的所有属性，operation，type，同时IR总是可以简化为上述途中的格式。这样统一的格式，就方便了MLIR解析和重新表示任何IR。定义方言代码形势tablegen通过代码操作,略定义OP定义参数和结果// 文档}];// 输入// 输出// 验证器，设置为1是为了生成1个默认的验证方法，该方法会在该OP的构造器完成后调用。
MLIR-Tutorials-Toy Tutorial
displayMessage的博客
05-30 660
玩具语言教程(Toy Tutorial) 第七章：向玩具语言增加一个复合类型(Chapter 7: Adding a Composite Type to Toy) 总结   在前一章中，我们展示了从Toy语言的编译前端到LLVM IR的端到端编译流。在本章中，我们将扩展Toy语言以支持新的复合结构类型(struct)。 在Toy中定义一个struct(Defining a struct in Toy)   首先，我们需要定义这种类型在Toy源语言中的接口。通常struct类型的语法如下： # A struc
MLIR Tutorials
CatkinLX的博客
06-22 685
MLIR Tutorial
MLIR toy笔记
CatkinLX的博客
06-07 546
MLIR 学习笔记
MLIR深入 —— 转换流程详解(以Toy接入为例)
ict_rtf的博客
11-11 2905
接入MLIR后的转换流程详解
基于Mlir语言的Quingo编程教程设计源码
最新发布
10-05
该项目是一款基于Mlir语言的Quingo编程教程设计源码，共计81个文件，涵盖31个Python脚本、29个Quingo脚本、6个QCIS配置文件、3个Markdown文档、3个Quingo格式配置文件、2个Jupyter Notebook、2个MLIR文件、1个Git...
cmake 构建路径_基于CMake构建系统的MLIR Example扩展
weixin_28681255的博客
01-04 362
上一篇文章讲了把pybind11的示例程序嵌入到了MLIR的Example中，但是在构建的过程中有一定运气成分，并不知道具体是怎么通过CMake构建系统编译出的共享库文件。在分析了MLIR各层级的CMakeLists.txt文件之后，本文讲述上一篇文章的共享库文件是如何在CMake的帮助下编译出来的。我们首先回顾一下上一篇文章中的构建过程，在MLIR的Example里面新增一个Ch8路径，将pyb...
【从零开始学深度学习编译器】十四，MLIR Toy Tutorials学习笔记之部分Lowering
I good vegetable a!
11-11 1255
0x0. 前言 这篇笔记是阅读Toy Tutorials的第五章之后总结的，这一节主要讲了一个Affine Dialect以及将之前获得的MLIR表达式（【从零开始学深度学习编译器】十三，如何在MLIR里面写Pass？ 这篇笔记末尾获得的MLIR表达式）进一步转换为Affine Dialect，并根据Affine Dialect中的冗余针对性的进行优化，这个转化被称作Lowering。 0x1. Dialect转换 MLIR有众多的Dialect，所以MLIR提供了一个统一的DialectConversio
【从零开始学深度学习编译器】十二，MLIR Toy Tutorials学习笔记一
I good vegetable a!
10-27 1045
0x0. 前言 上篇文章简单介绍了MLIR是什么，这篇文章将结合MLIR的 Toy Tutorials来进一步了解MLIR的全貌。 0x1. Chapter1: Toy语言和AST MLIR提供了一种Toy语言来说明MLIR的定义和执行的流程。Toy语言是一种基于张量的语言，我们可以使用它来定义函数，执行一些数学计算以及输出结果。下面要介绍的例子中限制Tensor的维度是<=2的，并且Toy语言中唯一的数据类型是64位浮点类型，对应C语言中的"double"。另外Values是不可以重写的，即每个操作
MLIR - 一种新的IR表示和编译器框架
csdndevpress0035的博客
07-24 258
MLIR（Multi-Level Intermediate Representation）是一种新型的用于构建可复用和可扩展的编译器的框架。
MLIR编译框架的使用与探索.zip
10-19
资源包含文件：课程报告word+源码 + 虚拟机软件：VirtualBox 6.1.32 + 操作系统：Ubuntu 20.04 + 内核版本：Linux kernel 5.13.0-35-generic 详细介绍参考：https://biyezuopin.blog.csdn.net/article/details/127414378
MLIR与Code Generation
吴建明wujianming_110117
09-23 397
MLIR与Code Generation MLIR多级中间表示 MLIR 项目是一种构建可重用和可扩展编译器基础架构的新方法。MLIR 旨在解决软件碎片问题，改进异构硬件的编译，显着降低构建特定领域编译器的成本，帮助将现有编译器连接在一起。 MLIR作用 MLIR 旨在成为一种混合 IR，可以在统一的基础架构中，支持多种不同的需求。例如，包括： • 表示数据流图的能力（例如在 TensorFlow 中），包括动态shape，user-extensible用户可扩展的操作生态系统，TensorFlow 变量等
Mlir环境配置以及yolov5模型转换_sophon文档mlir(1)，保洁阿姨看完都会了
2401_83946509的博客
04-13 951
为了做好运维面试路上的助攻手，特整理了上百道。
Buddy-MLIR 项目详解（入门 MLIR 极佳选择）
I good vegetable a!
06-05 1654
【GiantPandaCV】前几天洪滨介绍了他们PLTC的Buddy MLIR项目，感觉是一项比较有趣的项目。正值端午就看了一下这个项目并且大致理清了代码结构并且把相关的例子都跑了跑，这中间还发现了一些小BUG并提了一些小的修复的PR。所以这篇文章用来记录一下在我的视角下，Buddy-MLIR为什么是一个优秀的项目，它能为做编译器开发的同行或者小白用户带来什么样的帮助，Let’s Go!整个Buddy-MLIR项目给我的最大感觉就是，无论结果怎么样，我们都可以先 run 起来。虽然 MLIR 已经出现了几年
MLIR编译框架的使用与探索
毕业作品网站
10-20 1323
在 Parser.h 搜索"TODO"，可以看到需要补充的代码位置。TODO：语法变量必须以“var”开头，后面为变量名及类型，最后为变量的初始化。搜索 “TODO”，可以看到需要补充的代码位置。第三种类型 —— d[2][3] ——已成功识别。TODO：额外支持第三种新的形式。TODO：额外支持第三种新的形式。基础部分：词法分析与语法分析。对关键词和变量名进行分析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值