# /home/cds/model_repo/mobilenetv2-12.onnx
import onnx
from onnx import shape_inference
# Load the ONNX model
model = onnx.load("/home/cds/model_repo/mobilenetv2-12.onnx")
# 加载完模型是，这是一个N维度动态shape的onnx模型
# 请将N设置为1， 然后导出一个静态图
model.graph.input[0].type.tensor_type.shape.dim[0].dim_value = 1
# Perform shape inference
model = shape_inference.infer_shapes(model)
# 打印模型的计算图
print(onnx.helper.printable_graph(model.graph))
onnx.save(model, "/home/cds/model_repo/mobilenetv2-12-batch1.onnx")

#!/bin/bash

model_path="/home/cds/model_repo/mobilenetv2-12-batch1.onnx"
front_ir_name="mobilenetv2-12-batch1.mlir"
execute_name="mobilenetv2-12-batch1.vmfb"


iree-import-onnx ${model_path} \
  --opset-version 17 \
  -o=${front_ir_name}


iree-compile \
  ${front_ir_name}\
  --iree-hal-target-device=local \
  --iree-hal-local-target-device-backends=llvm-cpu \
  --iree-llvmcpu-target-cpu=host \
  -o ${execute_name}

# 可以查看执行的函数名为什么
iree-dump-module ./mobilenetv2-12-batch1.vmfb

iree-run-module \
  --module=${execute_name} \
  --device=local-task \
  --function=torch-jit-export \
  --input="1x3x224x224xf32=2"

主要的日志相关参数：

-mlir-print-ir-before-all - 在每个 pass 执行前打印 IR
-mlir-print-ir-after-all - 在每个 pass 执行后打印 IR
-mlir-print-ir-module-scope - 以完整模块范围打印 IR
-mlir-timing - 显示每个 pass 的执行时间
-mlir-print-op-on-diagnostic=true - 诊断时打印操作信息
-mlir-elide-elementsattrs-if-larger=N - 控制大型常量属性的打印

额外的调试选项：

--iree-llvmcpu-debug-symbols=true - 生成调试符号
--iree-vm-bytecode-module-output-format=flatbuffer-text - 输出可读的字节码格式
IREE_LLVM_EMBEDDED_LINKER_TOOL_VERBOSE=1 - 环境变量，增加链接器详细程度

bad.mlir

mlir-opt bad.mlir --your-pass

#!/bin/bash
mlir-opt "$1" --your-pass > /dev/null 2>&1
# 如果 mlir-opt 崩溃，返回非 0 → bug 还在

#!/bin/bash
mlir-opt "$1" --your-pass | grep "WRONG_CODE"

chmod +x test.sh

mlir-reduce bad.mlir -test=test.sh

Trying to reduce functions...
Trying to reduce operations...
Trying to reduce attributes...
...

reduced.mlir

def IREEEncoding_Dialect : Dialect {
  let name = "iree_encoding";
  let cppNamespace = "::mlir::iree_compiler::IREE::Encoding";
  let summary = [{
    A dialect designed for tensor encoding attributes and ops.
  }];
  let description = [{des}];
  let extraClassDeclaration = [{
    void registerAttributes();
  }];
  let useDefaultAttributePrinterParser = 1;
}

class IREEEncodingDialect : public ::mlir::Dialect {
  explicit IREEEncodingDialect(::mlir::MLIRContext *context);

  void initialize();
  friend class ::mlir::MLIRContext;
public:
  ~IREEEncodingDialect() override;
  static constexpr ::llvm::StringLiteral getDialectNamespace() {
    return ::llvm::StringLiteral("iree_encoding");
  }

  /// Parse an attribute registered to this dialect.
  ::mlir::Attribute parseAttribute(::mlir::DialectAsmParser &parser,
                                   ::mlir::Type type) const override;

  /// Print an attribute registered to this dialect.
  void printAttribute(::mlir::Attribute attr,
                      ::mlir::DialectAsmPrinter &os) const override;

    void registerAttributes();
  };

} // namespace mlir::iree_compiler::IREE::Encoding

// type
class MyDialect_Type<string name, string typeMnemonic, list<Trait> traits = []>
    : TypeDef<My_Dialect, name, traits> {
  let mnemonic = typeMnemonic;
}

// attribute
class MyDialect_Attr<string name, string attrMnemonic, list<Trait> traits = []>
    : AttrDef<My_Dialect, name, traits> {
  let mnemonic = attrMnemonic;
}

def IREEEncoding_SetEncodingOp : IREEEncoding_PureOp<"set_encoding",[
   DeclareOpInterfaceMethods<ReifyRankedShapedTypeOpInterface, ["reifyResultShapes"]>, Pure
  ]>

class SetEncodingOp : public ::mlir::Op<SetEncodingOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::RankedTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ReifyRankedShapedTypeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait>

if (auto iface = dyn_cast<SomeOpInterface>(op)) {
  iface.doSomething();
}

High-level tensor IR
   (mhlo / linalg / tensor)
        ↓
  Bufferization   ← 关键分水岭
        ↓
Low-level memory IR
   (memref / scf / affine)
        ↓
  Liveness / Allocation / Scheduling
        ↓
 Codegen

def SubOp : ToyOp<"sub", [Pure]> {
  let summary = "sub operation";
  let arguments = (ins AnyInteger:$lhs, AnyInteger:$rhs);
  let results = (outs AnyInteger:$result);
  let hasVerifier = true;
}

// hasVerifier

RewritePattern
OpRewritePattern
ConversionPattern
  
ConversionTarget
TypeConverter
  
  
GreedyPatternRewriteDriver
  
  
1. 一个自定义 Dialect
2. 一个自定义 op
3. 一个 canonicalization pattern  //规范化 / 化简 / 清理 IR。
4. 一个 lowering pass
5. 一个 TypeConverter
6. 一个 ConversionTarget
7. 一个 end-to-end mlir-opt 测试

做 canonicalization / peephole / fusion：
  用 OpRewritePattern。

做 linalg -> npu、tensor -> memref、high-npu -> low-npu：
  用 OpConversionPattern。

需要最底层灵活匹配 Operation *：
  用 RewritePattern。

提供给它剃光头感叹号用户九宫格火锅哥哥哥哥哥哥哥哥。  
PreservedAnalyses
mlir-opt pipeline
FileCheck 测试
  
  
  

重点不是“怎么写 pass 类”，而是：

哪些变换应该放在 tensor IR？
哪些变换应该放在 buffer/memref IR？
哪些变换应该放在 NPU-specific IR？
 
一般经验是：  
  图优化、算子融合、tile/fuse 尽量在 tensor / linalg 层做；
地址分配、DMA、bank conflict、buffer reuse 在 memref / NPU 层做；
descriptor 编码、寄存器字段、binary emit 放在最低层做。

tensor.empty
tensor.extract_slice
tensor.insert_slice
tensor.cast
ranked tensor type
dynamic shape
  
  linalg.generic
linalg.matmul
linalg.conv_2d_*
iterator_types
indexing_maps
destination-style op
  
  
memref.alloc
memref.subview
memref.load/store
memref.copy
strided layout
memory space
alignment

tensor -> memref
destination-passing style
buffer alias
in-place bufferization
alloc / dealloc
memref layout
memory space
ownership-based deallocation

lifetime analysis
SRAM allocation
static memory planning
tile buffer reuse
ping-pong buffer
DMA scheduling

mlir-opt // 验证和调试 MLIR pass 的主工具。
mlir-translate // MLIR 和其他格式之间互转的工具。
FileCheck // 检查输出文本是否符合预期 的工具。
lit // LLVM 的 测试运行器。批量运行测试文件里的 // RUN: 命令。

  mlir-opt
  用来运行 MLIR pass

mlir-translate
  用来在 MLIR 和外部格式之间转换

FileCheck
  用来检查命令输出是否符合预期

lit
  用来批量运行测试

-pass-pipeline
  用来精确指定 pass 执行顺序和层级

-dump-pass-pipeline
  用来查看最终 pipeline

-print-ir-before-all
  用来查看每个 pass 之前的 IR

-print-ir-after-all
  用来查看每个 pass 之后的 IR

-mlir-print-op-generic
  用 generic 格式打印 op，方便看清 MLIR 内部结构

1. 能读懂 linalg.matmul / linalg.conv / tensor / memref / scf IR
2. 能写一个自定义 Dialect
3. 能定义 3~5 个 NPU op
4. 能写 verifier 检查 shape/layout/attribute
5. 能写 canonicalization pattern
6. 能写一个 conversion pass
7. 能把 linalg.matmul lower 到 npu.matmul
8. 能把 tensor IR bufferize 到 memref IR
9. 能写一个简单 memory planning pass
10. 能用 mlir-opt + FileCheck 测试每个 pass