前言

在使用通用处理器如x86-64开发软件无线电算法的过程中，充分利用cpu的simd指令集（mmx/sse/avx/neon等）对于性能是至关重要的。现代的x86-64处理器能够支持很大的浮点向量运算，例如intel haswell（2011年发布）平台支持的avx指令集，ymm 0 ~ ymm15寄存器宽度为256bit，每条指令能实现8个单精度浮点数乘法或加法，4GHz主频运行linpack实测速度可达100Gflops。

AGC（自动增益控制）是软件无线电处理中最基本的算法之一。其目的是保持输出信号幅度基本稳定，以方便后续算法处理。AGC算法的工作流程可以总结为三步：

1. 放大信号。乘法运算，调整信号的幅度；

2. 检测信号幅度。对输出信号使用功率检波或者有效值检波，测量信号的实际幅度；

3. 调整增益。比较设定值与实际幅度的偏差，据此调整增益设置。

为了能够尽可能充分利用处理器的运算能力，编译器会对代码进行自动向量化，将多个浮点操作打包在一起，生成simd指令。因此，编写合适的代码结构对于性能是至关重要的。本文将对3种不同结构的AGC算法代码进行性能对比测试，以找出最优的方案。

算法实现方案

其中x y为float complex，pwr reference gain为float，全部对齐到16字节地址

for(i=0;i<n;i++) { step1: y="gain" * x; //MUL=2
    step2: pwr = y.re * y.re + y.im * y.im;   //MUL=2 ADD=1
}
step3: if(pwr > reference) gain *= 0.99;        else gain *= 1.01;  //CMP=1 MUL=1</n;i++)>

Total FLOPS = n * 5 + 2;

根据gcc编译器自动向量化的说明 （XXXXXXXXXXXXXXXXXXX/projects/tree-ssa/XXXXXXXXXXXXXXXXml） 编写了相应的测试代码。

其中算法1使用libvolk（）库的avx2实现，算法2和算法3使用c语言编写

//算法1for (i=0; i<*_num_iterations; i++) {   volk_32fc_s32fc_multiply_32fc(y, x, gain, n);
    volk_32fc_magnitude_squared_32f(pwry, y, n);
    *pwr = 0;    volk_32f_accumulator_s32f(pwr, pwry, n);
    *pwr /= n;
    if(*pwr > d_reference) gain *= a1;
    else gain *= a2;}</*_num_iterations;>

//算法2*pwr = 0;
for(int i = 0; i < n; i++)
{
    y[i] = x[i] * gain;//step1
    pwry[i] = real(y[i])*real(y[i]) + imag(y[i])*imag(y[i]);//step2.1
}
for(int i = 0; i < n; i++)
{
    *pwr += pwry[i];//step2.2
}
*pwr /= n;
if(*pwr > d_reference) gain *= a1;
else gain *= a2;//备注：经过测试, step1和step2.1放在同个循环，step2.2放在另外的循环中，速度最快。//step1 2.1 2.2分开三个循环，或者step1 2.1 2.2放在一起，或者step1分开step2.1 2.2放在一起，速度都会减慢//不使用pwry中间变量，直接累加到pwr，速度也会减慢

//算法3，手动展开循环，其中n是8的倍数*pwr = 0;
for(int i = 0; i < n; i+=8)
{
    y[i] = x[i] * gain;
    pwry[i] = real(y[i])*real(y[i]) + imag(y[i])*imag(y[i]);
    y[i+1] = x[i+1] * gain;
    pwry[i+1] = real(y[i+1])*real(y[i+1]) + imag(y[i+1])*imag(y[i+1]);
    y[i+2] = x[i+2] * gain;
    pwry[i+2] = real(y[i+2])*real(y[i+2]) + imag(y[i+2])*imag(y[i+2]);
    y[i+3] = x[i+3] * gain;
    pwry[i+3] = real(y[i+3])*real(y[i+3]) + imag(y[i+3])*imag(y[i+3]);
    y[i+4] = x[i+4] * gain;
    pwry[i+4] = real(y[i+4])*real(y[i+4]) + imag(y[i+4])*imag(y[i+4]);
    y[i+5] = x[i+5] * gain;
    pwry[i+5] = real(y[i+5])*real(y[i+5]) + imag(y[i+5])*imag(y[i+5]);
    y[i+6] = x[i+6] * gain;
    pwry[i+6] = real(y[i+6])*real(y[i+6]) + imag(y[i+6])*imag(y[i+6]);
    y[i+7] = x[i+7] * gain;
    pwry[i+7] = real(y[i+7])*real(y[i+7]) + imag(y[i+7])*imag(y[i+7]);
}
for(int i = 0; i < n; i+=8)
{
    *pwr += pwry[i]    + pwry[i+1] + pwry[i+2] + pwry[i+3] 
          + pwry[i+4]  + pwry[i+5] + pwry[i+6] + pwry[i+7];
}
*pwr /= n;
if(*pwr > d_reference) gain *= a1;
else gain *= a2;

以上测试代码分别循环iter次，其中iter=256*1048576/n，即测试的数据总长度不变。

使用getrusage函数得到循环的执行时间，进而计算出每秒处理的数据个数。

编译时，算法2和3均成功向量化

gcc 7.4.0//算法2agc_gr_bench.cc:105:20: note: loop vectorized
agc_gr_bench.cc:105:20: note: loop versioned for vectorization because of possible aliasing
agc_gr_bench.cc:105:20: note: loop turned into non-loop; it never loops.
agc_gr_bench.cc:105:20: note: loop with 7 iterations completely unrolled
agc_gr_bench.cc:110:20: note: loop unrolled 7 times
agc_gr_bench.cc:105:20: note: loop unrolled 3 times
agc_gr_bench.cc:108:12: note: loop unrolled 1 times//算法3agc_gr_bench.cc:139:20: note: loop vectorized
agc_gr_bench.cc:139:20: note: loop versioned for vectorization because of possible aliasing
agc_gr_bench.cc:159:20: note: loop unrolled 3 times
agc_gr_bench.cc:142:12: note: loop unrolled 1 times

备注: 作为对比，导入了gnuradio feed_forward_agc中的快速开平方拟合算法, 仅执行检波算法

//算法: agc_gr //测试方法：循环执行该函数iter*n次 inline static float envelope(gr_complex x)
{
    float r_abs = std::fabs(x.real());
    float i_abs = std::fabs(x.imag());

    if(r_abs > i_abs)
        return r_abs + 0.4 * i_abs;
    else
        return i_abs + 0.4 * r_abs;
}

测试环境

i7-4770k 2.6GHz

DDR3 2400 8GB

ubuntu 16.04 LTS

gcc 7.4.0 （备注: gcc 5.4.0速度减少10-15%，clang 3.8速度减少50%）

libvolk 1.4 (备注：未使用volk_modtool生成配置文件，使用默认的算法选择逻辑。)

存在问题：使用过volk_modtool之后最高可损失40%性能，架构选择a_sse3 u_sse3 a_avx u_avx均有此问题，原因不明。

测试结果

其次是手动展开循环的c代码（算法3），n=32时，处理速率1.24Gsps；

最慢的是简单循环（算法2），n=16时，处理速率0.85Gsps；

总结

若算法允许每次迭代处理多个数据（n值较大），应该优先使用libvolk库。

若算法要求迭代周期尽可能短（小的n值），应该用c语言自行编写展开的循环。

保持n值不要太大（使得数据能放入L1或L2缓存），否则性能会快速下降

源代码

agc_bench.tar.gz 31.88KB GZ 66次下载