📚 课程目录第4章性能度量指标

4. 性能度量指标

FIR滤波器，说白了就是音频DSP里最基础的“乘法累加”操作。你给它一串输入，它用一组固定的系数做加权求和，输出就是滤波后的结果。结构简单，但性能瓶颈往往就卡在这个“乘累加”上。

我刚开始做嵌入式音频时，觉得FIR不就是个卷积嘛，直接写个for循环就完事了。结果一跑，CPU占用率直接飙到80%。嗯，从那以后我才意识到——优化FIR，不是改算法，而是改数据怎么走、指令怎么发。

4.1 FIR滤波器的基本结构

先看最直接的实现。一个N阶FIR，每个输出样本需要N次乘法和N-1次加法。公式很简单：

y[n] = b0 * x[n] + b1 * x[n-1] + ... + bN * x[n-N]

代码写出来就是：

float fir_basic(float *coeff, float *buffer, int taps, int pos) {
    float sum = 0.0f;
    int i;
    for (i = 0; i < taps; i++) {
        int idx = pos - i;
        if (idx < 0) idx += taps;  // 环形缓冲区处理
        sum += coeff[i] * buffer[idx];
    }
    return sum;
}

这个版本，每个样本都要做一次取模运算。我当年在Cortex-M4上跑128阶FIR，采样率48kHz，单核直接干到80%负载。为什么？分支预测失败、内存访问不连续、循环开销大——三个坑全踩了。

核心瓶颈：FIR的优化空间不在数学上，而在数据流和指令流上。你想想看，每次循环都要计算索引、判断边界，这些开销比乘法本身还大。

4.2 对称系数优化

线性相位FIR有一个重要特性——系数对称。说白了就是：b0 = bN, b1 = bN-1, 以此类推。这个特性可以让我们把乘法次数砍掉一半。

对称结构公式：

y[n] = b0 * (x[n] + x[n-N]) + b1 * (x[n-1] + x[n-N+1]) + ...

代码实现：

float fir_symmetric(float *coeff, float *buffer, int taps, int pos) {
    float sum = 0.0f;
    int half = taps >> 1;
    int i;
    for (i = 0; i < half; i++) {
        int idx1 = pos - i;
        int idx2 = pos - (taps - 1 - i);
        if (idx1 < 0) idx1 += taps;
        if (idx2 < 0) idx2 += taps;
        sum += coeff[i] * (buffer[idx1] + buffer[idx2]);
    }
    // 如果阶数为奇数，处理中间系数
    if (taps & 1) {
        int mid = pos - half;
        if (mid < 0) mid += taps;
        sum += coeff[half] * buffer[mid];
    }
    return sum;
}

我在项目中遇到过一个问题：对称优化后乘法次数确实减半了，但索引计算反而更复杂。对于短滤波器（比如32阶以下），节省的乘法还不够抵消额外的寻址开销。所以我的建议是：阶数低于64时，对称优化的收益不明显。

滤波器阶数	原始乘法次数	对称优化后	实际加速比
16	16	8	1.2x
64	64	32	1.6x
256	256	128	1.9x
1024	1024	512	1.95x

经验之谈：对称优化最适合固定系数、高阶滤波器的场景。如果你的系数会动态更新，对称性可能被破坏，这时候就别用这个技巧了。

4.3 多相分解

多相分解，这个名字听起来挺唬人。其实它的核心思想很简单：把一个大FIR拆成多个小FIR，并行处理。特别适合多相滤波器组和多速率系统。

假设我们要做4倍插值，传统做法是先插零再滤波。但多相分解可以让你直接计算需要的输出样本，跳过那些没用的零值乘法。

多相分解公式：

y[n] = sum_{k=0}^{M-1} sum_{m=0}^{N/M-1} coeff[k + m*M] * x[n - m]

代码实现（4倍插值）：

void fir_polyphase(float *coeff, float *input, float *output, 
                   int taps, int blocks, int phase) {
    int poly_taps = taps / 4;  // 每个子滤波器的阶数
    int i, j;
    for (i = 0; i < blocks; i++) {
        float sum = 0.0f;
        for (j = 0; j < poly_taps; j++) {
            sum += coeff[phase + j * 4] * input[i - j];
        }
        output[i] = sum;
    }
}

我曾经在一个音频重采样项目里用多相分解，把采样率从44.1kHz转到48kHz。原始实现用直接FIR，每输出一个样本要算256次乘法。拆成4相后，每相只算64次乘法，计算量直接降到1/4。

注意：多相分解要求滤波器阶数能被相数整除。如果除不尽，要么补零，要么调整滤波器设计。我踩过这个坑——有一次没对齐，结果输出波形出现了周期性毛刺，查了两天才找到原因。

4.4 SIMD加速实现

SIMD，全称是Single Instruction Multiple Data。说白了就是一条指令同时处理多个数据。对于FIR这种数据并行度极高的操作，SIMD简直是天选之子。

ARM平台用NEON，x86平台用SSE/AVX。我以NEON为例，展示如何加速FIR：

#include <arm_neon.h>

void fir_neon(float *coeff, float *buffer, float *output, 
              int taps, int samples) {
    int i, j;
    float32x4_t sum_vec;
    float32x4_t coeff_vec, data_vec;
    
    for (i = 0; i < samples; i++) {
        sum_vec = vdupq_n_f32(0.0f);
        
        // 每次处理4个系数
        for (j = 0; j < taps; j += 4) {
            coeff_vec = vld1q_f32(&coeff[j]);
            data_vec = vld1q_f32(&buffer[i + j]);
            sum_vec = vmlaq_f32(sum_vec, coeff_vec, data_vec);
        }
        
        // 将4个部分和累加
        float sum = vaddvq_f32(sum_vec);
        output[i] = sum;
    }
}

这段代码，一次vmlaq指令做了4次乘法和4次加法。相比纯C循环，指令数减少到1/4。我在Cortex-A72上测试过，256阶FIR，48kHz采样率，纯C版本CPU占用35%，NEON版本直接降到9%。

但SIMD也有坑。我遇到过最典型的问题是内存对齐。NEON的vld1q要求16字节对齐，如果buffer地址不对齐，轻则性能下降，重则直接崩溃。我的习惯是：用posix_memalign或aligned_alloc分配内存，确保起始地址是16的倍数。

平台	SIMD指令集	寄存器宽度	单次处理样本数
ARMv7/v8	NEON	128位	4个float
x86	SSE	128位	4个float
x86	AVX2	256位	8个float
x86	AVX-512	512位	16个float

优化技巧：SIMD的瓶颈往往不在计算，而在内存带宽。如果数据不在缓存里，CPU只能干等。我建议把系数表放在连续内存里，并且预取下一批数据——用__builtin_prefetch或者手动循环展开。

4.5 四种优化策略对比

说了这么多，到底该用哪种？我整理了一张对比表，方便你根据场景选择：

优化策略	适用场景	加速比	实现复杂度	注意事项
对称系数	线性相位、高阶滤波器	1.5x - 2x	低	阶数低于64收益小
多相分解	多速率系统、重采样	2x - 4x	中	阶数需被相数整除
SIMD (NEON)	ARM平台、批量处理	3x - 5x	高	注意内存对齐
SIMD (AVX2)	x86平台、高性能需求	5x - 8x	高	功耗较高

我个人习惯是：先做对称优化（如果系数对称），再套SIMD加速。多相分解单独用于重采样场景。三种策略可以叠加使用，但要注意代码的可维护性——别为了性能把代码写成天书。

嗯，这张图把四种策略的关系理清楚了。你可以看到，结构优化和SIMD加速是两条独立路径，可以叠加。比如先做对称优化减少乘法次数，再用NEON并行计算，效果是乘法叠加的。

最后说一句：优化不是炫技，是解决问题。我见过有人为了用AVX-512，把代码改得面目全非，结果性能只提升了10%。不值得。先分析瓶颈在哪，再选合适的策略——这才是工程师该做的事。