企业官网建设流程全解析

1. 项目概述：当MLIR遇上高性能张量原语

如果你在深度学习或高性能计算领域折腾过一段时间，大概率会听说过LIBXSMM这个名字。它是一个专注于为小型矩阵乘法（GEMM）和卷积提供极致性能的库，尤其在x86架构上，通过手写汇编和JIT技术，能把那些看起来不起眼的小算子榨出惊人的性能。但LIBXSMM的“硬核”也带来了使用门槛——你得手动调用它的特定API，并且要为不同的硬件和问题规模做精细的调优。这就像给你一套顶级的手工工具，但没说明书，得靠老师傅的经验才能用好。

与此同时，MLIR（多级中间表示）作为编译器基础设施领域的新星，其核心思想是构建一个可扩展、可重用的中间表示和转换框架。它允许你定义自己的“方言”（Dialect），在不同抽象层次上表示和操作程序，然后通过一系列“Pass”（转换）将其逐步下译（Lowering）到更底层的表示，最终生成机器码。MLIR的出现，让编译器开发从“从头造轮子”变成了“乐高积木式”的搭建。

那么，一个很自然的问题就出现了：能否用MLIR这套现代化的编译器框架，来自动化地、智能地选择并生成最优的LIBXSMM内核（即Tensor Processing Primitives, TPPs）呢？这就是tpp-mlir项目要回答的问题。它本质上是一个桥梁，或者说是一个“编译器驱动”，将高层、抽象的线性代数操作（比如矩阵乘、卷积），通过MLIR的多级转换，自动映射到底层最高效的LIBXSMM微内核上。它的目标很明确：让开发者用高层、便携的方式写代码，同时由编译器自动保证在特定硬件上获得接近手写汇编的性能。

这个项目最初叫tpp-sandbox，现在迁移到了libxsmm组织下，更名为tpp-mlir，也标志着它从实验性沙箱向一个更正式、与LIBXSMM生态结合更紧密的工具演进。它不仅仅是一个MLIR方言的实现，更是一个完整的工具链，包含了类似LLVMopt的转换工具和runner那样的执行/基准测试工具，为其他上层AI编译器（如ONNX-MLIR、Torch-MLIR）利用LIBXSMM的能力提供了底层通道。

注意：理解这个项目需要对MLIR和深度学习算子优化有基本概念。如果你是编译器新手，可以把它想象成一个“自动变速箱”。你只管踩油门（写高层算子），它负责根据路况（硬件架构）和车速（数据规模），自动选择最合适的档位（TPP内核），让你既省心又跑得快。

2. 核心设计思路：为什么是MLIR+TPP？

在深入构建细节之前，我们有必要拆解一下tpp-mlir的核心设计哲学。它解决的痛点非常典型：性能可移植性（Performance Portability）与开发效率之间的矛盾。

2.1 传统优化路径的瓶颈

在TPP-MLIR出现之前，要利用LIBXSMM这类高性能库，通常有几种路径：

1. 直接调用LIBXSMM API：在C/C++代码中直接调用libxsmm_gemm等函数。这需要开发者对硬件（如AVX-512指令集）、数据布局（如内存对齐）、问题规模（如M、N、K维度）有深刻理解，并进行繁琐的参数调优。代码与硬件强绑定，移植到ARM等平台几乎要重写。
2. 使用高层框架的特定后端：例如，在PyTorch中通过一些扩展来调用LIBXSMM。这简化了调用，但优化决策是框架写死的，不够灵活，无法针对用户特定的计算图进行全局优化。
3. 手写或模板生成汇编：性能极致，但开发和维护成本是天文数字，非普通团队所能及。

这些路径要么太“底层”（难用），要么太“高层”（不够优化）。而MLIR的出现，提供了一种新的可能性：在中间层做文章。

2.2 MLIR带来的范式转变

MLIR的核心优势在于其“多层次”性。我们可以设计一个名为TPP的方言，用于表示那些可以被LIBXSMM高效实现的原子操作，例如：

• tpp.brgemm：批处理矩形矩阵乘法，这是LIBXSMM的看家本领。
• tpp.vnni_gemm：支持VNNI（向量神经网络指令）的矩阵乘，针对Intel DL Boost。
• tpp.relu,tpp.add等：激活函数和逐点操作，同样可以映射到LIBXSMM优化的版本。

这个TPP方言位于一个比较高的抽象层次，但它又足够“低级”，能够明确表达出那些对性能至关重要的属性，比如数据的布局（NCHW vs NHWC）、内存访问模式、并行策略等。

然后，MLIR的转换框架（Pass）就可以大显身手了：

1. 模式匹配与替换：一个Pass可以扫描MLIR程序，识别出符合特定模式的计算子图（例如，一个矩阵乘后面跟着一个ReLU激活），并将其整体替换为一个更高效的、融合的tpp.fused_brgemm_relu操作。这种算子融合是提升性能的关键，能减少中间结果的访存。
2. 参数化内核选择：另一个Pass可以根据目标硬件特性（CPU型号、支持的指令集）和具体的张量形状（M, N, K的大小），为每一个tpp.gemm操作选择最合适的LIBXSMM内核参数。例如，对于非常小的矩阵（如4x4），可能选择完全展开的标量代码；对于中等规模矩阵，选择AVX2向量化内核；对于适合缓存的大规模矩阵，选择AVX-512并调整循环分块策略。
3. 渐进式下译：TPP方言可以逐步下译到更接近硬件的LLVM方言或Vector方言。在这个过程中，可以插入平台特定的优化，比如为x86安排特定的寄存器分配策略，或者为ARM生成SVE指令。

简单来说，TPP-MLIR的设计思路是：定义一套“性能原语”方言，然后利用MLIR强大的分析和转换能力，自动、智能地将用户的高层计算描述，编译成由这些最优原语组装而成的程序。它把优化专家（LIBXSMM团队）的知识封装在了编译器Pass里，让普通开发者也能享受到顶尖的性能。

3. 环境搭建与项目构建实战

理论讲完了，我们上手实操。构建TPP-MLIR需要两步：先构建一个特定版本的LLVM/MLIR，再构建TPP-MLIR本身。官方推荐使用Clang和LLD链接器以获得最佳体验。

3.1 构建LLVM/MLIR基础框架

首先，我们需要一个“定制版”的LLVM项目，因为TPP-MLIR可能依赖于MLIR某个特定提交的特性或API。盲目使用系统包管理器安装的LLVM很可能版本不匹配。

# 1. 克隆LLVM项目仓库 git clone https://github.com/llvm/llvm-project.git # 2. 切换到TPP-MLIR兼容的版本。这是关键一步！ # 项目提供了一个版本文件，我们下载并用来checkout wget https://raw.githubusercontent.com/libxsmm/tpp-mlir/main/build_tools/llvm_version.txt pushd llvm-project git checkout `cat ../llvm_version.txt` popd rm llvm_version.txt # 3. 创建并进入构建目录 mkdir llvm-project/build pushd llvm-project/build # 4. 设置关键环境变量。CUSTOM_LLVM_ROOT将是我们自定义LLVM的安装根目录。 export CUSTOM_LLVM_ROOT=`pwd` # 注意，这里指向的是build目录，安装会在此目录下 echo $CUSTOM_LLVM_ROOT export PATH=$CUSTOM_LLVM_ROOT/bin:$PATH # 将新编译的工具链加入PATH首位 # 5. 使用CMake配置构建。这里有几个重要选项： # -G Ninja: 使用Ninja构建系统，比make更快。 # -DLLVM_ENABLE_PROJECTS="mlir": 我们主要需要MLIR，也可以加上clang, lld等。 # -DLLVM_TARGETS_TO_BUILD="host": 只构建当前主机架构的后端，加快编译。 # -DCMAKE_BUILD_TYPE=Release: 发布模式，优化程度高。调试时可改用Debug或RelWithDebInfo。 # -DLLVM_ENABLE_ASSERTIONS=ON: 即使在Release模式下也开启断言，便于排查问题。 # -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++: 强制使用Clang编译LLVM本身。 # -DLLVM_USE_LINKER=lld: 使用LLD链接器，链接速度更快。 cmake -G Ninja ../llvm \ -DLLVM_ENABLE_PROJECTS="mlir" \ -DLLVM_BUILD_EXAMPLES=ON \ -DLLVM_INSTALL_UTILS=ON \ -DLLVM_TARGETS_TO_BUILD="host" \ -DCMAKE_BUILD_TYPE=Release \ -DLLVM_ENABLE_ASSERTIONS=ON \ -DCMAKE_C_COMPILER=clang \ -DCMAKE_CXX_COMPILER=clang++ \ -DLLVM_USE_LINKER=lld # 6. 开始编译。这个过程视机器性能可能需要30分钟到数小时。 # 使用`ninja -jN`可以指定并行任务数，N通常等于你CPU的线程数。 ninja popd

编译成功后，$CUSTOM_LLVM_ROOT/bin目录下会有mlir-opt,mlir-translate,llc等工具，$CUSTOM_LLVM_ROOT/lib/cmake/mlir会有MLIR的CMake配置文件，这些是下一步构建TPP-MLIR所必需的。

实操心得：第一次构建LLVM可能会遇到各种依赖问题。在Ubuntu/Debian上，你可能需要安装libz-dev,libncurses5-dev等库。一个比较全的安装命令是：sudo apt-get install -y build-essential cmake ninja-build git libz-dev libncurses5-dev libedit-dev libxml2-dev liblzma-dev python3-dev。另外，如果机器内存较小（如小于16GB），在链接阶段可能会因内存不足而失败，可以尝试减少ninja -j的并行数，或者增加交换空间。

3.2 构建TPP-MLIR项目

有了定制的LLVM/MLIR，构建TPP-MLIR就相对直接了。项目会自动获取并编译其核心依赖LIBXSMM和LIBXSMM-DNN。

# 1. 克隆TPP-MLIR仓库 git clone https://github.com/libxsmm/tpp-mlir.git mkdir tpp-mlir/build pushd tpp-mlir/build # 2. 使用CMake配置，关键是指定我们刚编译的MLIR路径 cmake -G Ninja .. \ -DCMAKE_BUILD_TYPE=Release \ -DMLIR_DIR=$CUSTOM_LLVM_ROOT/lib/cmake/mlir \ # 指向MLIR的CMake配置目录 -DLLVM_EXTERNAL_LIT=$CUSTOM_LLVM_ROOT/bin/llvm-lit \ # 指定测试工具 -DCMAKE_C_COMPILER=clang \ -DCMAKE_CXX_COMPILER=clang++ \ -DLLVM_USE_LINKER=lld # 3. 编译并运行测试。`check-tpp`目标会编译所有代码并执行单元测试。 # 这是验证构建是否成功的最佳方式。 cmake --build . --target check-tpp popd

这里有两个重要的可选依赖：

• -DUSE_OpenMP=False：如果你不需要多线程支持（例如，只做单核性能测试或调试），可以关闭OpenMP。但对于实际性能评测，OpenMP是必须的，因为LIBXSMM和TPP-MLIR的许多内核都依赖它进行线程级并行。
• -DUSE_OneDNN=False：OneDNN（前身为MKL-DNN）是Intel推出的深度学习基础库。开启此选项后，TPP-MLIR的基准测试工具可以将自身生成的代码与OneDNN的性能进行对比，这对于验证和展示TPP-MLIR的优化效果至关重要。如果你是做研究或性能分析，建议开启。

构建成功后，你会在build/bin目录下得到几个关键工具：

• tpp-opt：类似于mlir-opt，专门用于加载和运行TPP方言相关的转换Pass。
• tpp-run：用于编译并执行包含TPP操作的MLIR模块，是运行基准测试和功能验证的主力。
• tpp-translate：将TPP MLIR转换到其他格式（如LLVM IR、汇编）。

3.3 使用Conda构建隔离环境（备选方案）

如果你的系统环境比较老旧或纯净（例如一台全新的云服务器），或者你不想污染系统环境，使用Conda/Mamba来创建一个包含所有编译依赖的独立环境是一个极佳的选择。TPP-MLIR的文档提供了详细的脚本。

# 初始化设置（以x86_64 Linux为例） export TPPMLIR_WORKSPACE_DIR=/path/to/your/workspace cd ${TPPMLIR_WORKSPACE_DIR} # 下载并安装Miniforge（一个轻量级的Conda发行版） wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh bash Miniforge3-Linux-x86_64.sh -b -p ${TPPMLIR_WORKSPACE_DIR}/miniforge3 # 初始化Conda Shell eval "$(${TPPMLIR_WORKSPACE_DIR}/miniforge3/bin/conda shell.bash hook)" conda activate # 激活base环境 # 安装所有必要的开发工具 # 注意：这里通过conda-forge频道安装了特定版本的clang, llvm, lld等 conda install -y cmake ninja git clang clangxx llvm lld llvm-openmp llvm-tools binutils conda install -y gcc_linux-64 gxx_linux-64 # 安装gcc工具链作为备用 python -m pip install coloredlogs # 可选，用于彩色日志

完成以上步骤后，你的Shell环境里就有了确定版本的Clang、LLVM、CMake等工具。之后，你只需要在需要时source一下conda的初始化脚本并激活环境，就可以在一个纯净、可控的环境中进行LLVM和TPP-MLIR的构建了，完全不影响系统其他软件。

避坑指南：Conda环境有时会与系统的动态库产生冲突。如果遇到奇怪的链接错误，可以尝试在CMake配置时显式指定库路径，或者使用conda提供的$CONDA_PREFIX环境变量。例如，确保CC和CXX环境变量指向的是conda环境中的clang：export CC=$CONDA_PREFIX/bin/clang export CXX=$CONDA_PREFIX/bin/clang++。

4. TPP-MLIR工具链使用与核心工作流解析

构建成功只是第一步，理解如何使用这些工具并看清其内部工作流，才能真正掌握TPP-MLIR。我们以一个简单的矩阵乘法为例，看看从高层MLIR到高效执行的完整链条是怎样的。

4.1 编写高层MLIR：从Linalg方言开始

通常，我们不会直接手写TPP方言。更常见的流程是，从一个更高层的方言（如Linalg，用于表示结构化线性代数）开始。假设我们有一个linalg.matmul操作，计算C = A * B。

我们可以创建一个名为simple_matmul.mlir的文件：

// 这是一个简化示例，省略了类型定义和内存布局等细节 func.func @main(%A: tensor<1024x512xf32>, %B: tensor<512x256xf32>) -> tensor<1024x256xf32> { %c0 = arith.constant 0.0 : f32 %init = linalg.init_tensor [1024, 256] : tensor<1024x256xf32> %filled = linalg.fill ins(%c0 : f32) outs(%init : tensor<1024x256xf32>) -> tensor<1024x256xf32> %result = linalg.matmul ins(%A, %B : tensor<1024x512xf32>, tensor<512x256xf32>) outs(%filled : tensor<1024x256xf32>) -> tensor<1024x256xf32> return %result : tensor<1024x256xf32> }

4.2 转换与下译：使用tpp-opt施加Pass

tpp-opt工具是转换的核心。我们可以编写一个转换Pipeline，将linalg.matmul逐步下译到tpp操作，再进一步下译到llvm。

# 假设我们已经构建好，并且当前在tpp-mlir/build目录下 # 使用tpp-opt工具，应用一系列转换Pass ./bin/tpp-opt ../../simple_matmul.mlir \ --convert-linalg-to-tpp \ # Pass 1: 将Linalg操作转换为TPP方言操作 --lower-tpp-to-loops \ # Pass 2: 将TPP操作下译为循环嵌套结构（scf方言） --convert-scf-to-cf \ # Pass 3: 将结构化控制流转换为基础控制流 --convert-cf-to-llvm \ # Pass 4: 将控制流转换为LLVM方言 --lower-tpp-to-llvm \ # Pass 5: 将剩余的TPP/向量操作下译为LLVM方言 --reconcile-unrealized-casts \ # Pass 6: 处理类型转换 > lowered_to_llvm.mlir

这个命令执行了一个完整的下译管道（Pipeline）。让我们拆解每个Pass的作用：

1. --convert-linalg-to-tpp：这是TPP-MLIR项目的核心Pass之一。它会模式匹配IR中的linalg.matmul操作，并根据一系列启发式规则（如矩阵形状、数据布局），将其替换为性能更优的tpp.brgemm或tpp.gemm操作。在这个过程中，Pass可能会进行自动的平铺（Tiling）和填充（Padding）优化。
2. --lower-tpp-to-loops：将抽象的tpp操作（如tpp.brgemm）下译为具体的、带循环的表示（使用MLIR的scf方言，即结构化控制流）。这时，计算的具体循环结构（如三层嵌套循环处理M、N、K）就显式化了。
3. 后续Pass：将循环和控制流进一步下译到MLIR的LLVM方言，这是一种非常接近LLVM IR的表示形式。

查看lowered_to_llvm.mlir文件，你会看到代码从高层的、声明式的张量操作，变成了一堆包含内存加载、存储、循环和LLVM内联汇编（对应LIBXSMM内核）的底层指令。这个过程完全由编译器自动化完成。

4.3 编译与执行：使用tpp-run

得到LLVM方言的MLIR后，我们需要将其编译成可执行文件并运行。tpp-run工具封装了这个过程。

# 直接编译并执行MLIR文件。tpp-run内部会调用mlir-cpu-runner等工具。 ./bin/tpp-run ../../simple_matmul.mlir \ --entry-point-result=f32 \ # 指定入口函数返回类型 --shared-libs=$CUSTOM_LLVM_ROOT/lib/libmlir_c_runner_utils.so,$PWD/../install/lib/libxsmm.so # 链接运行时库和LIBXSMM

更常见的是用tpp-run来做性能基准测试：

# 使用--benchmark选项。它会多次运行内核，统计执行时间、GFLOPS等指标。 ./bin/tpp-run ../../simple_matmul.mlir \ --entry-point-result=f32 \ --shared-libs=$CUSTOM_LLVM_ROOT/lib/libmlir_c_runner_utils.so,$PWD/../install/lib/libxsmm.so \ --benchmark

输出可能会是这样的：

--------------------------------------------------------------------- Benchmark Time CPU Iterations --------------------------------------------------------------------- BM_matmul/1024x512x256/manual_time 0.012 ms 0.012 ms 57692

这表示这个1024x512乘以512x256的矩阵乘法，平均耗时0.012毫秒。你可以通过这个数据，与直接调用LIBXSMM API或使用其他库（如OneDNN，如果编译时启用）的结果进行对比，验证TPP-MLIR自动优化的效果。

4.4 深入TPP方言与Pass开发

对于想要贡献或深度定制的开发者，理解TPP方言的定义和Pass的编写是关键。TPP方言的定义文件通常位于include/TPP/TPPOps.td（使用MLIR的ODS框架）。这里定义了一个操作（Operation）的接口、属性和参数。

例如，一个简化的GEMM操作可能定义为：

// 在TPPOps.td中 def TPP_GEMMOp : TPP_Op<"gemm"> { let summary = "TPP GEMM operation"; let arguments = (ins AnyMemRef:$A, // 输入矩阵A AnyMemRef:$B, // 输入矩阵B AnyMemRef:$C, // 输出矩阵C I64Attr:$m, // M维度 I64Attr:$n, // N维度 I64Attr:$k, // K维度 DefaultValuedAttr<F32Attr, "1.0">:$alpha, // 标量alpha DefaultValuedAttr<F32Attr, "0.0">:$beta // 标量beta ); let results = (outs); }

而一个将Linalg转换为TPP的Pass，其核心逻辑是重写规则（Rewrite Pattern）。在C++代码中，你会看到类似这样的模式匹配和替换：

// 在 ConvertLinalgToTPP.cpp 中 struct LinalgMatmulToTPP : public OpRewritePattern<linalg::MatmulOp> { LogicalResult matchAndRewrite(linalg::MatmulOp op, PatternRewriter &rewriter) const override { // 1. 检查op是否满足转换为TPP GEMM的条件（如数据类型、布局等） if (!isSupportedMatmul(op)) return failure(); // 2. 从linalg::MatmulOp中提取信息：内存引用、形状等 Value A = op.getInputs()[0]; Value B = op.getInputs()[1]; Value C = op.getOutputs()[0]; auto shapeA = A.getType().cast<MemRefType>().getShape(); int64_t m = shapeA[0], k = shapeA[1]; // ... 获取n // 3. 根据启发式规则选择TPP内核类型。例如，如果K维度较小且是批处理，可能选择brgemm。 bool useBrgemm = shouldUseBrgemm(m, n, k, /*其他因素*/); // 4. 创建对应的TPP操作，替换原有的linalg操作 if (useBrgemm) { rewriter.replaceOpWithNewOp<tpp::BrgemmOp>(op, A, B, C, m, n, k, /*alpha*/, /*beta*/); } else { rewriter.replaceOpWithNewOp<tpp::GemmOp>(op, A, B, C, m, n, k, /*alpha*/, /*beta*/); } return success(); } };

这个模式匹配器会在MLIR的转换过程中被调用，一旦识别到linalg::MatmulOp，就尝试用更优化的tpp::BrgemmOp或tpp::GemmOp替换它。这就是编译器自动优化的魔法发生的地方。你可以通过添加更多、更复杂的模式匹配规则，来让TPP-MLIR识别并优化更多的计算模式，比如带有偏置的矩阵乘（GEMM+Add）、矩阵乘接激活函数（GEMM+ReLU）等。

5. 性能调优与高级特性探索

TPP-MLIR不仅仅是一个“翻译器”，它更是一个优化框架。要发挥其最大威力，需要理解并利用其高级特性和调优旋钮。

5.1 利用平铺（Tiling）和缓存（Cache）优化

对于大型矩阵乘法，直接调用一个巨大的内核往往不是最优的，因为数据可能无法完全驻留在高速缓存中。这时需要循环分块（Tiling）。TPP-MLIR的Pass可以自动进行平铺优化。

在转换Pipeline中，你可以在下译到TPP之前，插入--linalg-tilePass：

./bin/tpp-opt input.mlir \ --linalg-tile="tile-sizes=64,64,32" \ # 在M, N, K维度上进行分块 --convert-linalg-to-tpp \ ... (后续下译步骤)

这个Pass会将一个大的linalg.matmul分解为多个小的、在L1/L2缓存中更友好的小块矩阵乘法。然后，每个小块再被--convert-linalg-to-tpp转换为tpp.gemm。平铺大小的选择是一门艺术，它取决于目标CPU的缓存大小（L1, L2, L3）。TPP-MLIR可能内置了一些针对常见CPU（如Intel Ice Lake, AMD Zen）的启发式规则，但你也可以通过实验来寻找特定工作负载的最优分块策略。

5.2 融合（Fusion）优化

融合是减少中间结果访存、提升性能的关键技术。例如，在深度学习推理中，一个卷积或矩阵乘后面经常跟着ReLU、BatchNorm等逐点操作。

TPP-MLIR可以通过模式匹配，识别出“GEMM + 偏置加法 + ReLU”这样的计算链，并将其融合为一个单独的、更复杂的TPP操作（如果LIBXSMM提供了对应的融合内核），或者生成一个更紧凑的循环结构，在其中连续执行这些操作而不写回中间结果。

在代码层面，这需要编写更复杂的重写规则。例如，一个匹配“Matmul + Add + ReLU”的Pattern，会检查这三个操作是否在数据流上连续且没有其他干扰，然后将其替换为一个新的、自定义的tpp::FusedMatmulAddReluOp。这个新操作在后续下译时，可以调用LIBXSMM高度优化的融合内核，或者生成一个手调的高效循环。

5.3 面向特定硬件的内核选择

LIBXSMM为不同的CPU指令集（SSE, AVX2, AVX-512, AVX-512 VNNI, AMX等）提供了不同的内核实现。TPP-MLIR的--convert-linalg-to-tppPass在运行时可以检测CPU特性，并自动选择最适合的TPP内核变体。

这通常是通过MLIR的TargetAttr（目标属性）和动态分发机制实现的。编译器可以生成一个“分发”函数，在程序运行时检查cpuid，然后跳转到对应指令集版本的内核代码。TPP-MLIR通过链接LIBXSMM的JIT库，甚至可以在运行时根据具体的矩阵形状即时生成最优的汇编代码，实现真正的“自适应优化”。

5.4 与上游AI编译器的集成

TPP-MLIR的最终价值在于被上游的AI编译器使用。例如，ONNX-MLIR项目可以将ONNX模型导入为MLIR，然后在其优化Pipeline中调用TPP-MLIR提供的Pass，将模型中的线性代数部分下译成高性能的TPP代码。类似地，Torch-MLIR也可以做同样的事情。

这种集成通常通过两种方式：

1. 作为转换库：其他项目将TPP-MLIR作为库链接，直接调用其C++ API（如registerTPPConversionPasses()）来将TPP转换Pass添加到自己的Pipeline中。
2. 作为Dialect和Pass集合：其他项目的MLIR代码在需要时，可以引入TPP方言，并依赖TPP-MLIR的Pass进行下译。这要求两个项目基于相同版本的LLVM/MLIR构建。

6. 常见问题排查与调试技巧

在实际使用和开发TPP-MLIR的过程中，你肯定会遇到各种问题。这里记录一些典型问题的排查思路和调试技巧。

6.1 构建失败问题

6.2 运行时/功能性问题

6.3 调试与开发技巧

1. 打印中间表示（IR）：这是调试MLIR编译器最强大的工具。除了tpp-opt的--print-ir-*系列选项，你还可以在C++ Pass代码中插入op->dump()来打印特定操作，或者使用rewriter.getListener()来跟踪重写过程。
2. 使用MLIR的调试工具：mlir-tblgen用于查看从ODS定义生成的C++代码；mlir-lsp-server可以与支持LSP的编辑器（如VSCode）集成，提供语法高亮和跳转；mlir-reduce可以帮助你自动缩小触发错误的测试用例。
3. 编写Lit测试：TPP-MLIR使用LLVM的Lit测试框架。当你添加一个新Pass或修复一个Bug时，最好的实践是同时添加一个测试文件（.mlir），用// RUN:行指定要运行的Pipeline，并用// CHECK:行断言预期的输出。这保证了功能的可重复性和回归测试。
4. 性能剖析：对于性能问题，可以使用perf或vtune工具对tpp-run生成的程序进行剖析。关注热点函数是落在LIBXSMM的内核里，还是在MLIR生成的胶水代码（如循环开销、边界处理）上。如果胶水代码占比高，可能需要调整平铺策略或循环展开。

构建和运行TPP-MLIR的过程，本质上是在实践一套现代化的编译器开发工作流。从高层算法描述到底层性能优化，MLIR提供了一条清晰、可插拔的路径。而TPP-MLIR则是一个绝佳的案例，展示了如何利用这套框架，将领域专业知识（高性能张量计算）封装成可重用的编译器组件，最终让更广泛的开发者受益。虽然目前它仍处于快速发展阶段，但其设计理念和已经实现的功能，已经为我们指明了未来AI编译器的一个重要发展方向。