【x86向量化】三种不同方式的AGC算法代码运行速度对比

前言

在使用通用处理器如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

Total FLOPS = n * 5 + 2;

根据gcc编译器自动向量化的说明 (https://gcc.gnu.org/projects/tree-ssa/vectorization.html) 编写了相应的测试代码。

其中算法1使用libvolk()库的avx2实现,算法2和算法3使用c语言编写

//算法1
for (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;
}
//算法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
//算法2
agc_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
//算法3
agc_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均有此问题,原因不明。

测试结果

 volk库速度最快,在向量长度n=1024时,处理速率1.75Gsps;

其次是手动展开循环的c代码(算法3),n=32时,处理速率1.24Gsps;

最慢的是简单循环(算法2),n=16时,处理速率0.85Gsps;

总结

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

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

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

源代码

agc_bench.tar.gz31.9k3次下载

[修改于 10 个月前 - 2019-01-03 17:57:01]

来自 软件综合
 
4
2019-1-2 14:53:53
1楼

SDR的算法有并行化加速的空间吗

折叠评论
加载评论中,请稍候...
折叠评论
2019-1-3 14:33:14
2楼

现在正在学编代码的同学前来膜拜。

折叠评论
加载评论中,请稍候...
折叠评论

想参与大家的讨论?现在就 登录 或者 注册

插入资源
全部
图片
视频
音频
附件
全部
未使用
已使用
正在上传
空空如也~
上传中..{{f.progress}}%
处理中..
上传失败,点击重试
{{f.name}}
空空如也~
(视频){{r.oname}}
{{selectedResourcesId.indexOf(r.rid) + 1}}
ID:{{user.uid}}
{{user.username}}
{{user.info.certsName}}
{{user.description}}
{{format("YYYY/MM/DD", user.toc)}}注册,{{fromNow(user.tlv)}}活动
{{submitted?"":"投诉"}}
请选择违规类型:
{{reason.description}}
支持的图片格式:jpg, jpeg, png