关于深度学习:借助-mperf-进行矩阵乘法极致优化

作者：旷视 MegEngine 架构师 洪超

前言

单精度矩阵乘法（SGEMM）是十分典型的计算密集型算子，对 SGEMM 的优化也常常被当作算子优化从业人员的练手我的项目。本文将借助于 mperf，在 ARM A55 cpu 外围上对 SGEMM 的性能进行极致优化，过程中会展现 mperf 辅助性能优化工作的根本逻辑。心愿本文的读者对计算机体系结构有肯定理解，并且能够补充一些 TMA 的根底概念。另外，对于本文应用的 mperf 工具，更多具体介绍请参见之前的文章 mperf 介绍。

本文须要优化的计算指标是 C=AB，假如矩阵 A 大小为 MK，矩阵 B 大小为 KN，则失去矩阵 C 大小为 MN。为了后文分块操作的不便，这里假如 M，N 是 4 的倍数，并抉择 M=N=K 别离为 100，200，300，500，700，900 的矩阵尺寸，对不同优化版本进行性能测试。本文所有试验代码均在 mperf/apps/cpu_pmu_analysis 目录下。

矩阵乘法优化

寄存器和 FPU 优化——Naive 实现到循环展开

矩阵乘法的 Naive 实现为三层循环计算：

//lda：number of columns of A 
//ldb：number of columns of B
//ldc：number of columns of C 
#define A(i, j) a[(i)*lda + (j)]
#define B(i, j) b[(i)*ldb + (j)]
#define C(i, j) c[(i)*ldc + (j)]
void my_matmul_naive(int m, int n, int k, float* a, int lda, float* b, int ldb,
              float* c, int ldc) {
    int i, j, p;
    for (i = 0; i < m; i++) {for (j = 0; j < n; j++) {for (p = 0; p < k; p++) {C(i, j) = C(i, j) + A(i, p) * B(p, j);
            }
        }
    }
}

此时，测试 M=N=K 别离为 100，200，300 时的 mperf 性能数据见 Naive_mperf , 对于这些测试数据的简略介绍请参见 mperf 测试数据。
测试命令(后文其余优化版本的测试命令不再反复贴出)：

First, compile the testcase, using `/android_build.sh -m arm64-v8a`.
Then, copy build_dir/apps/arm_cpu_matmul_naive to your android platform, and run it.

从下面链接的 mperf 数据能够看到 Naive 实现的 GFLOPS 甚至不到 0.5，而 mperf 在 ARM A55 平台实测的峰值浮点算力能够达到 14GFLOPs，显然咱们还有很长的路要走。

剖析 TMA Level-1 的数据，也即比拟 Frontend_Bound、Bad_Speculation、Backend_Bound 和 Retiring 的占比，能够发现占比最高的为 Backend_Bound，约为 50%，据此首先能够判断 Naive 版本的性能瓶颈位于处理器后端。进一步看 TMA Level-2 及以上级别的数据，发现 Backend_Bound 中占比最大的是 Core_Bound，而 Interlock_Bound 又占 Core_Bound 的 95% 以上，紧接着 Interlock_FPU 又简直占 Interlock_Bound 的 100%。

由此可得，以后的瓶颈在于 Interlock_FPU，Interlock_FPU 占比大阐明浮点计算触发了大量的 pipeline stall。除此之外，咱们还察看到 Metric_Neon_Port_Util 为 0，这是因为 Naive 版本没有进行向量计算。

对于如何升高 Interlock_FPU，咱们晚期基于 mperf 做过验证，证实 unroll 能够无效升高 Interlock_FPU，过程如下:

#define UNROLL_RAW1(cb, v0, a...) \
    cb(0, ##a) 
#define UNROLL_RAW2(cb, v0, a...) \
    cb(0, ##a) cb(1, ##a) 
#define UNROLL_RAW5(cb, v0, a...) \
    cb(0, ##a) cb(1, ##a) cb(2, ##a) cb(3, ##a) cb(4, ##a)
#define UNROLL_RAW10(cb, v0, a...) \
    UNROLL_RAW5(cb, v0, ##a)       \
    cb(5, ##a) cb(6, ##a) cb(7, ##a) cb(8, ##a) cb(9, ##a)
#define UNROLL_RAW20(cb, v0, a...)                                          \
    UNROLL_RAW10(cb, v0, ##a)                                               \
    cb(10, ##a) cb(11, ##a) cb(12, ##a) cb(13, ##a) cb(14, ##a) cb(15, ##a) \
            cb(16, ##a) cb(17, ##a) cb(18, ##a) cb(19, ##a)
#define UNROLL_CALL0(step, cb, v...) UNROLL_RAW##step(cb, 0, ##v)
#define UNROLL_CALL(step, cb, v...) UNROLL_CALL0(step, cb, ##v)
#define THROUGHPUT(cb, func, UNROLL_NUM)                                    \
    static int func##_throughput_##UNROLL_NUM() {                           \
        asm volatile(                                                       \
        UNROLL_CALL(UNROLL_NUM, eor)                                        \
        "mov x0, %x[RUNS]\n"                                                \
        "1:\n"                                                              \
        UNROLL_CALL(UNROLL_NUM, cb)                                         \
        "subs  x0, x0, #1 \n"                                               \
        "bne 1b \n"                                                         \
        :                                                                   \
        : [RUNS] "r"(mperf::RUNS)                                           \
        : "cc", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", \
          "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18",    \
          "v19", "x0");                                                     \
        return mperf::RUNS * UNROLL_NUM;                                    \
    }
#define cb(i) "fmla v" #i ".4s, v" #i ".4s, v" #i ".4s\n"
THROUGHPUT(cb, fmla, 20)
THROUGHPUT(cb, fmla, 10)
THROUGHPUT(cb, fmla, 5)
THROUGHPUT(cb, fmla, 2)
THROUGHPUT(cb, fmla, 1)

在这个例子中，别离对不进行循环展开和以粒度为 2、5、10、20 的循环展开的 fmla 计算进行测试，后果如下：

通过这个简略的例子咱们能够看到，随着循环展开粒度的减少，Interlock_FPU 会逐步升高，并逐步趋于稳定。这是因为没有循环展开或循环展开特地小的时候，上一次循环还没有执行实现，下一次循环又要读取雷同的寄存器，进而造成寄存器依赖。要打消寄存器依赖，首先要保障循环体中不同条指令应用不同的寄存器，并且尽量保障循环体内指令的条数大于该指令的 latency 和该指令的 throughput 的乘积。以本文在 a55 平台测试 fmla 向量计算为例，fmla 的 latency 为 4 个 cycle，并且 a55 处理器后端只有一个 port 能够执行 fmla 向量计算，也即 fmla 的 throughput 为 1，所以要求循环体 fmla 指令数大于 4 * 1 才能够解除寄存器依赖，这也合乎上述试验后果的变动状况。

了解下面信息后，咱们思考在 Naive 版本上进行循环展开，并根据 Naive 版本 Metric_Neon_Port_Util 为 0，同时施加 SIMD 优化。具体做法是，先对后面的行列采纳 812 开展，对残余的列采纳 84 开展，再对残余的行先采纳 412 开展，最初用 44 开展，期间配合 ARM NEON 指令进行向量化操作。

这里抉择 8*12 是为了更充沛的利用寄存器资源，是因为 ARM A55 下面有 32 个 128 bit 向量寄存器，以及思考到本文最初 matmul 汇编版本的最内层实现大体如下（留神这里应用的外积计算矩阵乘，具体参见外积算矩阵乘）：

• 从 A 矩阵读 8 个 float 到 2 个向量寄存器，此时应该是 8 行外面每行的第一个数。
• 从 B 矩阵读 12 个 float 到 3 个向量寄存器，应该是 12 列里每列的第一个数。
• 用 fmla 指令，让 B 的每个 float 别离乘以 A 的两个向量寄存器，产生 24 个向量后果，也全副存储在寄存器中(24 个向量寄存器存储 8×12=96 个两头后果)。

采纳 8*12 开展之后的代码构造如下：

void my_matmul_unroll(int m, int n, int k, float* a, int lda, float* b, int ldb,
                      float* c, int ldc) {
    int i, j;

    for (i = 0; i + 8 <= m; i += 8) {for (j = 0; j + 12 <= n; j += 12) {AddDot8x12(k, &A(i, 0), lda, &B(0, j), ldb, &C(i, j), ldc);
        }
        for (; j < n; j += 4) {AddDot8x4(k, &A(i, 0), lda, &B(0, j), ldb, &C(i, j), ldc);
        }
    }
    if (i != m) {for (j = 0; j + 12 <= n; j += 12) {AddDot4x12(k, &A(i, 0), lda, &B(0, j), ldb, &C(i, j), ldc);
        }
        for (; j < n; j += 4) {AddDot4x4(k, &A(i, 0), lda, &B(0, j), ldb, &C(i, j), ldc);
        }
    }
}

对于循环展开，能够用一个图来直观地了解，这里 mr=8，nr=12，咱们每次用 A 矩阵的 8 K 的小块和 B 矩阵的 K 12 小块来计算 C 的一个 8 * 12 小块：

用 mperf 剖析 unroll 版本的 matmul 实现，具体数据见[Unroll_mperf] (https://www.megengine.org.cn/blog/mperf2#:~:text=Metric_GFLOP…,Unroll_mperf,-M%3DN%3DK)

比照 M，N，K 较小时(注: 在优化寄存器和 FPU 单元利用率的时候能够把问题规模先限度得比拟小，缩小访存相干 issue 的烦扰)，Unroll 版本与 Naive 版本的 Interlock_FPU、Metric_Neon_Port_Util 和 GFLOPS：

能够看到循环展开后能够看到 Interlock_FPU 占比降落显著，同时 Metric_Neon_Port_Util 显著回升，而 GFLOPS 指标有了数量级的进步，阐明充分利用寄存器资源和进步 FPU 利用率无效进步了程序性能。

访存优化——分块和 PACK

上图是 Unroll 版本与 Naive 版本在不同矩阵尺寸下的性能比照，能够看到循环展开在矩阵尺寸比拟小的状况下，性能晋升还是很显著的，然而随着矩阵尺寸增大 unroll 的成果迅速降落。所以当初咱们将注意力转移到，如何解决矩阵尺寸增大 GFLOPS 降落的问题。通过剖析上节链接的 unroll 版本的 mperf 数据，能够看到，随着矩阵尺寸变大到肯定水平，Memory_Bound 占比逐步靠近 50%，代替之前的 Interlock_FPU 成为新的性能瓶颈。而 Memory_Bound 占比高次要是 Load_Cache 造成的，这就指明了咱们接下来须要进行访存相干的优化。

分块

之所以矩阵尺寸减少，unroll 版本的性能会降落，次要起因就是数据无奈全副驻留在 Cache 中，导致数据频繁地在 Cache 和主存之间换入换出，而处理器对主存的拜访是十分低廉的。为了缩小对主存的反复访存，首先咱们能想到的就是分块(Unroll 版本中提到的分块是内层分块，目标是优化寄存器和 FPU 的利用率，请留神辨别)，将分块之后的数据保留在 Cache 中，尽量使处理器发动的访存操作都能命中 cache 中的数据。

这里咱们抉择对 N，K 维别离进行 Nr 和 Kr 粒度的分块，联合循环展开局部的逻辑，整体的分块形式即为：外层选取 A 矩阵的 MKr 小块和 B 矩阵的 KrNr 小块，内层再对这两个小块别离进行 mr 行和 nr 列的划分，所以最终内层每次计算 mrKr 的 A 小块和 Krnr 的 B 小块，失去 C 矩阵 mr*nr 小块的局部两头后果。

对于如何确定 Nr 和 Kr 的大小，咱们的指标就是使得计算时须要用到的分块能够依据访存频繁的水平保留在 CPU 的各级存储中，准则就是拜访越频繁的分块存储在速度越快的存储上，以及保障优先用满速度快的存储资源之后再下溢。针对 matmul, 具体约束条件设定为：

• 将反复访存率最高的 mr*nr 大小的 C 小块保留在访存速度最快的寄存器上(unroll 版本就是这样假如的)。
• 将下图中红色局部 (包含计算完一个 mrNr 的 C 行块须要反复拜访次数最多的 mr Kr 的 A 行块，内层一次计算迭代须要用到的 Kr*nr 大小的 B 列块) 都保留在 L1 中。
• 因为计算完每一个 mrNr 的 C 行块，都须要反复遍历一次整个 KrNr 大小的 B 块，因而心愿将 KrNr 大小的 B 块寄存在 L2 中，使得每次读取 Krnr 的 B 列块的时候，都是从 L2 中读取。

根据下面的调配策略，并联合 CPU 中的各级存储资源 (寄存器数量，L1D 和 L2) 的尺寸，便能够确定最佳的 Nr，Kr 取值：

• 能够依据 CPU 处理器的寄存器数量失去 mr 和 nr 的具体大小，寄存器容量 >
  mr*nr (unroll 版本就是遵循这个约束条件取的 mr=8,nr=12)
• 依据 L1D Cache 的大小联合 mr 和 nr 计算出 Kr，Kr=L1D/(mr+nr)
• 再依据 L2 的大小计算出 B 矩阵中的 Nr，Nr=(L2-L1D)/Kr

在 ARM A55 上，最终失去的 Nr 为 252，Kr 为 256。留神：这里计算失去 Nr 为 256，然而因为咱们抉择 nr 为 12，因而为了防止不必要的余数解决，抉择 Nr 为 12 的倍数简化问题。

Kr/Nr 分块的代码逻辑如下：

#define kc 256
#define nc 252
void my_mamtmul_block(int m, int n, int k, float *a, int lda, float *b, int ldb,
              float *c, int ldc) {
  int j, p, pb, ib;
  for (p = 0; p < k; p += kc) {pb = min(k - p, kc);
    for (j = 0; j < n; j += nc) {ib = min(n - j, nc);
      InnerKernel(m, ib, pb, &A(0, p), lda, &B(p, j), ldb, &C(0, j), ldc);
    }
  }
}

增加 Kr/Nr 分块后的 mperf 性能数据见 Block_mperf

比照 Kr/Nr 分块前后以下变动显著的数据：

Kr/Nr 分块后能够看到在矩阵较大时进行疾速矩阵乘法，GFLOPS 的确回升不少，Load_Cache 和 Metric_L3D_RD_Miss_Ratio 等均有显著降落。这阐明 Kr/Nr 分块的确大幅缩小了对 latency 十分大的零碎主存的拜访，优化了程序的访存性能。

数据 PACK

剖析 Kr/Nr 分块后测得的 mperf 数据，能够看到随着矩阵尺寸变大，性能也能放弃绝对稳固，没有显著降落。然而此时 mperf 拿到的 TMA 指标显示，Backend_Bound 中的 Memory_Bound 占比仍旧很高，性能瓶颈还是停留在访存局部。

进一步思考，在计算 mrnr 大小的 C 小块的时候，每一次迭代都须要读取 A 矩阵 mr1 的数据，而本文测试的矩阵数据都是行主序，即不同行雷同列的数据是内存不间断的，访存不间断就意味着对 Cache 不敌对。同样在不同次迭代中，须要读取矩阵 B 中不同行的 1*nr 小块的数据，天然也存在数据读取不间断的状况。思考到在分块计算 matmul 的逻辑下，A 的所有行块和 B 中的所有列块将被读取屡次，因而能够通过对 A 和 B 提前进行数据 PACK，这样只在第一次 PACK 时候对 Cache 不敌对，而前面计算的时候屡次拜访数据均为间断访存，因而收益微小。
下图阐明了对 A/B 矩阵别离 PACK 的过程：

void InnerKernel(int m, int n, int k, float* a, int lda, float* b, int ldb,
                 float* c, int ldc) {
    int i, j;
    float packedA[m * k];
    float packedB[k * n];

    for (i = 0; i + 8 <= m; i += 8) {PackMatrixA_8(k, &A(i, 0), lda, packedA + i * k);
        for (j = 0; j + 12 <= n; j += 12) {if (0 == i) {PackMatrixB_12(k, &B(0, j), ldb, packedB + j * k);
            }
            AddDot8x12(k, packedA + i * k, k, packedB + j * k, 12, &C(i, j),
                       ldc);
        }
        for (; j < n; j += 4) {if (0 == i) {PackMatrixB_4(k, &B(0, j), ldb, packedB + j * k);
            }
            AddDot8x4(k, packedA + i * k, k, packedB + j * k, 12, &C(i, j),
                      ldc);
        }
    }
    if (i != m) {PackMatrixA_4(k, &A(i, 0), lda, packedA + i * k);
        for (j = 0; j + 12 <= n; j += 12) {AddDot4x12(k, packedA + i * k, k, packedB + j * k, 12, &C(i, j),
                       ldc);
        }
        for (; j < n; j += 4) {AddDot4x4(k, packedA + i * k, k, packedB + j * k, 12, &C(i, j),
                      ldc);
        }
    }
}

PACK 后的 mperf 性能数据见 Pack_mperf

比照 PACK 前后的数据：

能够看到进行 PACK 优化后 GFLOPS 又有肯定幅度的增长。此时能够察看到 L1D_TLB_Miss_Ratio 有所升高，并且在 M=N=K >= 700 时 L2D_TLB_REFILL 明显降低，阐明 PACK 的确能够通过缩小缺页的产生，缩小 TLB miss，从而晋升性能。

pipeline 优化——嵌入汇编

剖析 PACK 之后的 mperf 数据，能够发现 Backend_Bound 占比 40% 以上，其中 Core_Bound 类别下的 Interlock_FPU 再次成为性能瓶颈。回忆 unroll 版本缩小 Interlock_FPU 的思路，是通过循环展开给编译器更大的优化空间，让编译器充分利用寄存器来缩小流水线依赖，但编译器也是有局限的。一般来说，编译器思考到通用性，是很难生成针对特定处理器架构特点的最优汇编实现的（ARM in-order 架构的小核上更是如此）。因而下一步的想法就是优化编译器生成的汇编，通过把内层计算逻辑替换为嵌入式汇编，根据架构个性调整指令抉择和指令排布，进一步缩小 pipeline 上的依赖和抵触，从而达成升高 Interlock_FPU 的目标。

首先，咱们比照了 PACK 版本的 mperf 数据中的 FPU_util 和纯算力测试状况下的 FPU_util，发现 PACK 版本的 FPU_util 绝对低了很多。也就是说，PACK 版本的 matmul 对处理器 SIMD 单元的利用率还是有肯定晋升空间的（下这个判断的一个前提也是思考到前文曾经对 matmul 访存局部优化得很充沛了，并且思考到内层循环中没有分支判断等简单逻辑，只是比拟存粹的访存和计算指令的 interleave。换句话说，汇编优化个别是留到最初进行的）。

其次，咱们留神到编译器生成的汇编代码中，数据加载应用的是 ldq 指令(ldq 指的是 armv8 isa 中 128bit load 操作)，然而联合下面 FPU_util 数值比现实状况低的察看（会关注 ldq 指令，是因为咱们理解到 ARM A55 的访存能力弱，一个 cycle 最多 load 64bit，store 128bit），咱们有理由狐疑 ldq 指令的抉择可能会造成 pipeline stall。通过查问 ARM A55 trm 手册，咱们发现 ldq 在 a55 上须要两个 cycle 能力 issue 进来，并且 ldq 跟 fmla 不能双发射(注：ARM A55 是双发射架构)，这就证实了 ldq 会造成计算和访存指令无奈双发射，并造成 Metric_FPU_util 数值的降落。进一步，咱们发现 ldr,ldx,ins 三种指令都能与 fmla 双发射，且发射周期都是 1 个 cycle，而这三条指令能够组合出 ldq 等价的操作。因而，咱们应用 ldr,ldx,ins 指令组合来替换 ldq 指令，就能够进步流水线的满载水平，进而进步性能。

咱们用一个小的测试例子来进行验证：思考上面两段代码：优化前，应用 ldq 指令加载数据，代码如下：

asm volatile("fmla v1.4s, v1.4s, v1.s[0]\n"
                "ld1 {v0.4s}, [%[b_ptr]]\n"
                "fmla v2.4s, v2.4s, v2.s[0]\n"
                "ld1 {v7.4s}, [%[b_ptr]]\n"
                "fmla v3.4s, v3.4s, v3.s[0]\n"
                "fmla v4.4s, v4.4s, v4.s[0]\n"
                "fmla v5.4s, v5.4s, v5.s[0]\n"
                "fmla v6.4s, v6.4s, v6.s[0]\n"
                : [b_ptr] "+r"(b_ptr)
                :
                : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");

优化后，将 ldq 拆分为 ldr，ldx，ins 指令加载数据，代码如下：

asm volatile("fmla v1.4s, v1.4s, v1.s[0]\n"
               "ldr d0, [%[b_ptr]]\n"
               "fmla v2.4s, v2.4s, v2.s[0]\n"
               "ldr x0, [%[b_ptr], #8]\n"
               "fmla v3.4s, v3.4s, v3.s[0]\n"
               "ins v0.d[1], x0\n"
               "fmla v4.4s, v4.4s, v4.s[0]\n"
               "ldr d7, [%[b_ptr]]\n"
               "fmla v5.4s, v5.4s, v5.s[0]\n"
               "ldr x0, [%[b_ptr], #8]\n"
               "fmla v6.4s, v6.4s, v6.s[0]\n"
               "ins v7.d[1], x0\n"
               : [b_ptr] "+r"(b_ptr)
               :
               : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");

咱们对优化前和优化后的版本进行测试，对剖析 mperf 拿到的数据，看到次要的变动为：

能够看到 Metric_Load_Port_Util 和 Metric_GFLOPs_Use 均晋升显著，也就验证了后面的猜测。

因而，在嵌入的汇编代码中，咱们利用下面提到的加载指令的替换，测得的 mperf 性能数据见：ASM_mperf

比照剖析 PACK 和 ASM 两个版本的 mperf 数据，能够看到 Metric_Neon_Port_Util 和 Metric_Load_Port_Util 均显著回升。

留神到实现汇编优化后，在矩阵大小 M，N，K <= 300 时，GFLOPS 性能曾经达到峰值算力的 90% 以上，基本上能够断定较小尺寸的状况下，matmul 在 ARM A55 平台上曾经优化到位了。而当 M，N，K 比拟大时，仍旧有进一步的优化空间。然而思考到本文的次要目标，是借助 matmul 优化来阐明 mperf 能够给性能优化工作带来哪些助益，所以就不持续进一步的优化关工作了。

总结

本文以 ARM A55 平台上的矩阵乘优化为例，具体介绍了如何用 mperf 剖析以后实现的性能体现，找到性能瓶颈，进而确定下一步的优化方向，如此重复迭代，最终获得了靠近硬件性能峰值的性能体现。本文各个版本 matmul 的性能比照，见下图：

附录

mperf 测试数据

这里贴了不同优化版本的 mperf 测试数据，每一个版本下的测试数据都蕴含两局部：一部分是非 Metric 前缀命名的，都是 TMA 范式下的指标；另一部分是 Metric 前缀命名的则是非 TMA 范式下，然而对性能优化有辅助作用的指标。这两类指标都是基于 PMU 原始 event 四则运算加工失去的，具体的计算公式请参见 ARM a55 tma。

另，TMA 范式下的指标出现多级开展的关系，因为以后 mperf 未提供可视化工具，请参考下图示意的层级关系进行对号入座。并且，请留神附录贴的 TMA 数值均为无穷纲百分比。

Naive_mperf

Unroll_mperf

Block_mperf

Pack_mperf

ASM_mperf

术语表

1. TMA: 也即 Top-down Microarchitecture Analysis 的缩写。TMA 是 intel 工程师为剖析 intel X86 cpu 微架构的性能瓶颈而总结的方法论，可参见 intel x86 TMA。一句话总结的话，TMA 就是一种在微架构层面自顶而下的瓶颈定位办法。mperf 在 ARM cpu 上实现了 TMA 的方法论，并进行了包含本文在内的实际验证。
2. Core_Bound: This metric represents fraction of slots where Core non-memory issues were of a bottleneck. Shortage in hardware compute resources; or dependencies in software’s instructions are both categorized under Core Bound. 示意 CPU 处理器后端非访存相干的 stall 引起的性能损失，通常包含 ALU 单元的资源有余，以及流水线上的指令依赖引起的 stall 等。
3. Interlock_Bound: No operation issued due to the backend interlock. 示意 CPU 处理器后端因为产生了 pipeline interlock 而产生的 stall, pipeline interlock 就是 A 指令的执行依赖 B 指令某一个 pipeline stage 的后果，而 B 指令还没有执行到对应 stage，指令 A 就等 stall 期待依赖条件满足，比方 raw 依赖。思考到本文中频繁呈现对于处理器 pipeline 以及 pipeline interlock 相干的术语，如果读者对这部分概念比拟含糊，举荐一个很好的教学文档 mips pipeline。
4. Interlock_FPU: No operation issued due to the backend, interlock, FPU. This event counts every cycle that issue is stalled and there is an interlock that is due to an FPU/NEON instruction. 这个指标是下面 Interlock_Bound 的子类别，表征由 FPU/NEON 指令的 pipeline interlock 而产生流水线进展的比例，比方前文升高 Interlock_FPU 的试验中，如果循环体中只有一个 fmla v0.4s, v0.4s, v0.4s 指令，下一个循环 iter 的 fmla 指令须要读取 v0 的数值，这就依赖上一个 iter 的 fmla 指令更新完 v0，而 fmla 指令的 latency 是多个 cycle，也就造成了相邻 iter 见 fmla 指令的 interlock, 流水线中将产生大量 stall。
5. Load_Cache: No operation issued due to the backend, load, Cache miss. 表征因为 Cache 读提早导致的 stall。
6. Metric_Neon_Port_Util: 处理器后端 neon port 的利用率，计算公式是 ASE_SPEC/(CYCLES*NEON_PORTS)，拿理论执行的 neon 指令数除以处理器运行的 cycle 和处理器后端反对 neon 操作的 port 端口数的乘积，ARM a55 的 NEON_PORTS 是 1，在这里用于表征处理器 neon 单元的利用率。
7. Metric_L3D_RD_Miss_Ratio: L3 Cache 读的缺失率，计算公式是 L3D_CACHE_REFILL_RD/L3D_CACHE_RD。
8. Metric_Load_Port_Util: 处理器后端 load port 的利用率，计算公式是 LD_SPEC/(CYCLES*LD_PORTS)，拿理论执行的 load 指令数除以处理器运行的 cycle 数和处理器后端反对 load 操作的 port 端口数的乘积，ARM a55 的 LD_PORTS 是 1，在这里用于表征处理器 LD 单元的利用率。
9. L1D_TLB_Miss_Ratio: 表征的是 L1D 的 TLB miss 的比例，L1D TLB miss 会触发 L2D TLB 的 read。

10. L2D_TLB_REFILL: 表征的是 L2D 的 TLB miss 的数量，会触发低廉的 page table walker。

    附

    更多 MegEngine 信息获取，您能够：查看文档和 GitHub 我的项目，欢送参加 MegEngine 社区奉献，成为 Awesome MegEngineer，荣誉证书、定制礼品享不停。