这篇文章讨论如何将 AST 转换为真正的 MLIR 代码。
方言
说到创建方言,我们首先要回答一个基本问题:方言到底是什么?
方言由以下部分组成:
- 前缀:所有操作所在的命名空间,例如这里的
Toy。 - 类型:自定义类型。
- 操作:具有不变量、语义和 trait 的自定义操作。
- Pass:分析或转换程序、优化该方言的编译器处理步骤。
定义方言,本质上就是定义这些组成部分。
操作与不透明 API
MLIR 的创新之一是完全以操作为基础。如果看过 LLVM IR 或汇编,你会发现其中存在函数、指令、基本块等多种实体。这种设计的问题是,某些概念与特定架构耦合,从而影响灵活性和可扩展性。
[这里或许可以补充一个例子]
在 MLIR 中,一切都基于操作,函数也是操作。操作通过不透明的定义方式获得充分的可定制能力。
%t_tensor = "toy.transpose"(%tensor) {inplace = true} : (tensor<2x3xf64>) -> tensor<3x2xf64> loc("example/file/path":12:1)
操作包含以下组成部分:
- 类型。例如,
toy.transpose接收一个张量并输出一个张量。 - 属性:包含零个或多个属性的字典。属性是一类始终为常量的特殊参数,使同一种操作可以表达更多变化。
- 输入和输出。
- 源代码位置标识。
基本块与区域
基本块是一组操作,类似 LLVM 中的 basic block。基本块必须以分支或返回等终结操作结束。
区域是嵌套在操作中的基本块列表。由于函数也是操作,函数体就是一个区域。区域内的 SSA 值可以引用区域外的值,反之则不行。
定义方言(Ops.td)
我们用 TableGen 定义方言。TableGen 提供声明式描述能力,可以省去大量样板代码。
# define the namespace
def Toy_Dialect : Dialect {
let name = "toy";
let cppNamespace = "::mlir::toy";
}
# define the base for toy op. It inherits the base Op class
include "mlir/IR/OpBase.td"
class Toy_Op<string mnemonic, list<Trait> traits = []> :
Op<Toy_Dialect, mnemonic, traits>;
然后为每种操作定义:
- arguments:输入。
- results:输出。
- builders:构造函数。
- 验证器。
// Notice we inherit from Toy_Op here!!
// "constant" is the mnemonic for this op
def ConstantOp : Toy_Op<"constant", [Pure]> {
// Provide a summary and description for this operation. This can be used to
// auto-generate documentation of the operations within our dialect.
let summary = "constant";
let description = [{
Constant operation turns a literal into an SSA value. The data is attached
to the operation as an attribute. For example:
```mlir
%0 = toy.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]>
: tensor<2x3xf64>
```
}];
// The constant operation takes an attribute as the only input.
let arguments = (ins F64ElementsAttr:$value);
// The constant operation returns a single value of TensorType.
let results = (outs F64Tensor);
// Indicate that the operation has a custom parser and printer method.
let hasCustomAssemblyFormat = 1;
// Add custom build methods for the constant operation. These method populates
// the `state` that MLIR uses to create operations, i.e. these are used when
// using `ConstantOp::create(builder, ...)`.
let builders = [
// Build a constant with a given constant tensor value.
OpBuilder<(ins "DenseElementsAttr":$value), [{
build($_builder, $_state, value.getType(), value);
}]>,
// Build a constant with a given constant floating-point value.
OpBuilder<(ins "double":$value)>
];
// Indicate that additional verification for this operation is necessary.
let hasVerifier = 1;
}
这里添加了两个自定义 builder。默认情况下,只要没有禁用默认 builder,就会自动生成完整形式的构造函数:
builder.create<toy::ConstantOp>(loc, type, denseAttr)
为方便使用,也可以添加自定义 builder:
builder.create<toy::ConstantOp>(loc, denseAttr)从 denseAttr 推导输出类型。builder.create<toy::ConstantOp>(loc, 1.0)是构造 f64 常量的简写重载。
函数操作也值得一看。其参数包括符号名、函数类型(输入到输出)、参数列表和返回值列表。注意,MLIR 函数可以返回多个结果。
def FuncOp : Toy_Op<"func", [
FunctionOpInterface, IsolatedFromAbove
]> {
let summary = "user defined function operation";
let description = [{
The "toy.func" operation represents a user defined function. These are
callable SSA-region operations that contain toy computations.
Example:
```mlir
toy.func @main() {
%0 = toy.constant dense<5.500000e+00> : tensor<f64>
%1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
toy.print %1 : tensor<2x2xf64>
toy.return
}
```
}];
let arguments = (ins
SymbolNameAttr:$sym_name,
TypeAttrOf<FunctionType>:$function_type,
OptionalAttr<DictArrayAttr>:$arg_attrs,
OptionalAttr<DictArrayAttr>:$res_attrs
);
let regions = (region AnyRegion:$body);
let builders = [OpBuilder<(ins
"StringRef":$name, "FunctionType":$type,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
>];
let extraClassDeclaration = [{
//===------------------------------------------------------------------===//
// FunctionOpInterface Methods
//===------------------------------------------------------------------===//
/// Returns the argument types of this function.
ArrayRef<Type> getArgumentTypes() { return getFunctionType().getInputs(); }
/// Returns the result types of this function.
ArrayRef<Type> getResultTypes() { return getFunctionType().getResults(); }
Region *getCallableRegion() { return &getBody(); }
}];
let hasCustomAssemblyFormat = 1;
let skipDefaultBuilders = 1;
}
我们还需要调用函数的操作。它接收函数符号和参数列表,输出函数执行的结果;由于目前只有张量类型,返回值也都是张量。
def GenericCallOp : Toy_Op<"generic_call"> {
let summary = "generic call operation";
let description = [{
Generic calls represent calls to a user defined function that needs to
be specialized for the shape of its arguments. The callee name is attached
as a symbol reference via an attribute. The arguments list must match the
arguments expected by the callee. For example:
```mlir
%4 = toy.generic_call @my_func(%1, %3)
: (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
```
This is only valid if a function named "my_func" exists and takes two
arguments.
}];
// The generic call operation takes a symbol reference attribute as the
// callee, and inputs for the call.
let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<F64Tensor>:$inputs);
// The generic call operation returns a single value of TensorType.
let results = (outs F64Tensor);
// Specialize assembly printing and parsing using a declarative format.
let assemblyFormat = [{
$callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
}];
// Add custom build methods for the generic call operation.
let builders = [
OpBuilder<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
];
}
实现方言(Dialect.cpp)
TableGen 只负责生成声明。实现方言,主要是为每种操作实现以下四个方法:
build:操作的构造函数。parse:从文本解析并构造操作。print:parse的逆过程,将操作输出为文本。verify:检查操作是否合法。
因此,首先引入定义并完成注册:
#include "toy/Dialect.cpp.inc"
/// Dialect initialization, the instance will be owned by the context. This is
/// the point of registration of types and operations for the dialect.
void ToyDialect::initialize() {
addOperations<
#define GET_OP_LIST
#include "toy/Ops.cpp.inc" // this is the output of tablegen
>();
}
继续以常量操作为例:
// build op
void ConstantOp::build(mlir::OpBuilder &builder, mlir::OperationState &state, double value) {
auto dataType = RankedTensorType::get({}, builder.getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute);
}
mlir::ParseResult ConstantOp::parse(mlir::OpAsmParser &parser,mlir::OperationState &result) {
mlir::DenseElementsAttr value;
// OpAsmParser is LLVM builtin that we can directly leverage
if (parser.parseOptionalAttrDict(result.attributes) ||
parser.parseAttribute(value, "value", result.attributes))
return failure();
result.addTypes(value.getType());
return success();
}
void ConstantOp::print(mlir::OpAsmPrinter &printer) {
printer << " ";
printer.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{"value"});
printer << getValue();
}
llvm::LogicalResult ConstantOp::verify() {
// If the return type of the constant is not an unranked tensor, the shape
// must match the shape of the attribute holding the data.
auto resultType = llvm::dyn_cast<mlir::RankedTensorType>(getResult().getType());
if (!resultType)
return success();
// Check that the rank of the attribute type matches the rank of the constant
// result type.
auto attrType = llvm::cast<mlir::RankedTensorType>(getValue().getType());
if (attrType.getRank() != resultType.getRank()) {
return emitOpError("return type must match the one of the attached value "
"attribute: ")
<< attrType.getRank() << " != " << resultType.getRank();
}
// Check that each of the dimensions match between the two types.
for (int dim = 0, dimE = attrType.getRank(); dim < dimE; ++dim) {
if (attrType.getShape()[dim] != resultType.getShape()[dim]) {
return emitOpError(
"return type shape mismatches its attribute at dimension ")
<< dim << ": " << attrType.getShape()[dim]
<< " != " << resultType.getShape()[dim];
}
}
return mlir::success();
}
实现 MLIR 生成(MLIRGen.cpp)
现在实现 MLIR 生成函数,将 AST 转换为 MLIR 操作。
mlirGen 是对外的公共 API。
// The public API for codegen.
mlir::OwningOpRef<mlir::ModuleOp> mlirGen(mlir::MLIRContext &context,
ModuleAST &moduleAST) {
return MLIRGenImpl(context).mlirGen(moduleAST);
}
实现的入口接收 AST 模块,对每个函数调用 mlirGen,再对函数体中的每个操作调用对应的 mlirGen。
class MLIRGenImpl {
public:
MLIRGenImpl(mlir::MLIRContext &context) : builder(&context) {}
/// Public API: convert the AST for a Toy module (source file) to an MLIR
/// Module operation.
mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
// We create an empty MLIR module and codegen functions one at a time and
// add them to the module.
theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
for (FunctionAST &f : moduleAST)
mlirGen(f);
// Verify the module after we have finished constructing it, this will check
// the structural properties of the IR and invoke any specific verifiers we
// have on the Toy operations.
if (failed(mlir::verify(theModule))) {
theModule.emitError("module verification error");
return nullptr;
}
return theModule;
}
例如,下面的代码使用 AddOp::create 创建加法操作,后者会调用之前定义的 build 函数。
mlir::Value mlirGen(BinaryExprAST &binop) {
// First emit the operations for each side of the operation before emitting
// the operation itself. For example if the expression is `a + foo(a)`
// 1) First it will visiting the LHS, which will return a reference to the
// value holding `a`. This value should have been emitted at declaration
// time and registered in the symbol table, so nothing would be
// codegen'd. If the value is not in the symbol table, an error has been
// emitted and nullptr is returned.
// 2) Then the RHS is visited (recursively) and a call to `foo` is emitted
// and the result value is returned. If an error occurs we get a nullptr
// and propagate.
//
mlir::Value lhs = mlirGen(*binop.getLHS());
if (!lhs)
return nullptr;
mlir::Value rhs = mlirGen(*binop.getRHS());
if (!rhs)
return nullptr;
auto location = loc(binop.loc());
// Derive the operation name from the binary operator. At the moment we only
// support '+' and '*'.
switch (binop.getOp()) {
case '+':
return AddOp::create(builder, location, lhs, rhs);
case '*':
return MulOp::create(builder, location, lhs, rhs);
}
emitError(location, "invalid binary operator '") << binop.getOp() << "'";
return nullptr;
}