前面一个篇章:算法的嵌入式移植(一)C代码优化部分 侧重语言层面的优化,而更多针对DSP特性进行的优化将在本篇章进行介绍 ,内容大多是摘抄书本和网络资源,因为是整理以往的笔记,来源已经不可靠了,不过不影响其中内容的经典。
一. 前序
1.图像算法在嵌入式移植时(主要针对DSP芯片)优化的原则和步骤?
原则:算法效果达到预期之前最好不要做过多的优化
步骤:windows下的算法级优化—>C语言的优化—>DSP下的C编译器优化(如软件流水等) —>C语言代码和结构的优化(如浮点转定点) —> (线性)汇编做极限优化
2.需要对程序中的哪些代码进行优化?
大家都知道程序中最费时的莫过于循环操作了,主要是针对循环进行优化(一般我都是针对100次以上的循环进行优化,特别是复杂度在O(m*n)以及O(n^2)以上的循环优化)(关于循环中复杂度的计算方法大嘴会在以后介绍,请留意)。
二. 较详细的介绍
1.算法级优化
算法效果达到预期之前最好不要做过多的优化,为啥?算法未稳定就草率
优化是做算法和移植的大忌,一是因为算法以后修改后你还得优化,二是各种优化后你的算法代码如果未充分注释,多日后可能连本人都无法看懂。
算法级优化举例:
大的方面:在做算法前咱们首先要衡量的算法本身的复杂度和效果,如背景建模/前景检测(即运动目标检测)采用的是“单高斯”?“混合高斯(GMM)”?“VIBE”?“codebook”?等等;
小的方面:针对某一基本算法函数优化,比如采用的sobel边缘检测,还是canny边缘检测,或者其他更好的方法。选择一个效果好又稳定的算法方向和基本函数对以后的移植和优化会有很大帮助。
再比如:你非要用神经网络做车牌识别,在PC下当然可以,但在嵌入式中却无法实时,也许有牛人真能在DSP下基于神经网络做高效又稳定的、识别率又高的车牌识别(如8168和C66系列芯片),至少在大嘴身边未发现。
2.C语言的优化
C语言本身优化是老生常谈,这里不做介绍,比如什么少用if…else之类,这里不再复述,感兴趣的朋友请自己在网络上找资料。
3.DSP下的C编译器优化
3.1设置编译选项,使编译器先自行优化
最主要的编译选项:O1,O2,O3等几个等级(如DSP开发环境CCS中自带的可选编译选项)
代码风格没有充分遵守CCS编译器的约定则会导致编译器不做优化,即使开了不同等级,也还是不会做优化,日后大嘴会逐步介绍
3.2开通软件流水(software pipelining),针对内层循环,使多次迭代并行执行
方法和注意事项
(i)方法:设置编译选项(一大堆),
是否开启软件流水,通过生成的.asm文件查看
(ii)无法开启流水的一些原因
代码风格(如过多的条件跳转指令条件寄存器个数有限,达到资源限)、错误编译选项等等
3.3使用内联inline和intrinsic函数(可归类为代码级优化)
说的不多,但展开了内容却很多,详细的还要靠大家去研究下TI提供的那几本手册(C6000优化编译器手册、C6000程序员手册、C6000汇编手册等),建议主要看英文原版,中文版(《TMS320C6000系列DSP编程工具与指南》)作为辅助(几年前阅读过,个人觉得里面很多翻译的不是很到位)。
4.DSP代码和结构的优化
4.1浮点转定点(PC和DSP下可通用)
浮点数:是属于有理数中某特定子集的数的数字表示,在计算机中用以近似
表示任意某个实数。具体的说,这个实数由一个整数或定点数(即尾数)乘以某个基数(计算机中通常是2)的整数次幂得到,这种表示方法类似于基数为10的科学计数法。
定点数:参与运算的数的小数点位置固定不变
浮点数形式上可以简单认为是float和double类型,定点数形式上可以简单认为是个整数。
(i)简单方法:在精度满足的情况下:把数据放大n倍,运算后再缩小,
(ii)但为了准确把握好精度,通常用Q定标小数点移位(关于Q定标小数点移位较复杂,大嘴以后专门介绍)
4.2算术和逻辑运算
(i)能用移位和逻辑运算的绝不用加减乘除
(ii)能用加减法的绝不用乘除法,
(iii)能用乘法的绝不用除法
(iv)能用16位(16位 * 16位= 32位结果)乘法的绝不用32位乘法,DSP有相应16位乘法器(硬件),而32位成为一般用软实现.
4.3打包操作
(i)手动:32位机,int打包,一次加载4个 byte像素(PC和DSP下可通用)
(ii)半手动:仅DSP下可用,预编译伪指令(如MUST_ITERATE),intrinsic函数,需要首地址4字节对齐
例:
#pragma MUST_ITERATE(8,32,8); //告诉编译器要采用优化(如软件流水),//循环最小次数为8,最大次数为32,循//环为8的整数倍
for(i = 0; i < 32;i = 8)
{
*pdst = _abs(*psrc);
}
d)inline和intrinsic函数
(i)inline ,语句只能几行,有各种限制
(ii)intrinsic函数,总是被内联,汇编封装,常用一些操作函数和数**算(如求绝对值,乘法),速度很难超越,intrinsic函数不影响软件流水,TI充分考虑到这点
4.4充分利用Bit图(bit二值图),针对二值图的操作,
注意:不要和windows位图(bitmap)混淆
(1)传统的二值像素: 0和255
unsigned char A = 255;
255 == 11111111
unsigned char B = 0;
0 == 00000000
(2)基于比特图
unsigned char A;
A 10101110 (A中存了8个像素)
(3)分析:
a)基于像素操作(慢):每个二值像素占1个字节(8位,即8个bit);基于bit图操作(快):每个像素占1位(1个bit)
b)32bit包和8bit包
32bit包,可放于1个int类型的变量中,其充分利用了32位机每次加载
一个字,这样相当于一次加载32个二值像素
例:
传统的遍历每个像素(320个unsigned char像素)
for(i = 0; i < 320;i )
{
//传统的像素操作,无法并行
}
循环跳转320次,无法并行操作
基于比特图(长度为10个int型数组即可存储320个像素)
for(i = 0; i < 10;i )
{
//32bit图打包 并行操作,每32个像素可以并行执行
}
理论上提高了32倍,至少20倍以上
c)汇编->内存和寄存器、寄存器和寄存器之间频繁操作
节省大量数据搬移时间
d)Bit二值图主要针对腐蚀、膨胀、各种滤波、轮廓查找等等和二值图相关的操作,内部只采用与、或、非、移位等运算而没有加减乘除,所以超快
Bit图的所有操作写程序比较困难,一旦写成则效率大幅提升
4.5使用DMA和Cache
(1)DMA
直接存储器存取,块儿复制数据,不需要CPU 进行干预,数据直接在源地址和目的地址之间传送,不需要是中间媒介。
CSL的DMA操作,主要有3个DMA函数
DAT_copy() –> 对应C语言非DMA操作:memcpy()
DAT_fill() –>对应C语言非DMA操作:memset()
DAT_copy2d –>CSL的DMA的块拷贝,如拷贝一个矩阵
要求8字节对齐,即源地址和目的地址必须是8 的倍数
字节对齐后硬件可直接加载字,为了兼容正在迅速普及的64位机,使得你的程序可以不经修改直接编译成 64 位程序
如果没有一点发展的眼光,在现在这种 32 到 64 位过渡时期他不这样做的话将会导致太多的32位平台上开发的程序为了能运行在64位平台上不得不修改源代码。那样不仅会大大增加软件成本,还会导致人们为了不改动程序而拒绝接受64位平台。
(2)cache
Cache较小,但速度快,内层循环中最费时的部分要用L2 cache,高速缓存的速度超快。
这里简单知道下即可,篇幅有限,以后再慢慢介绍
4.6 restrict和register
int * restrict a;
int * restrict b;
restrict保证所定义的指针指向特定对象的唯一指针,即存储器不相关,否则默认编译器认为存储器相关,会影响编译器的优化
register int i;
4.7 DSP下专有的视觉库(VLIB,封装)和开源图片库(IMGLIB)
使用(VLIB,封装)和开源图片库(IMGLIB)里面包括一些基础图像处理函数,将更多的时间留给自己的其它各种优化,节省时间。
5.(线性)汇编做极限优化
如果觉得采用上述优化后算法效率仍未达到要求,最后可以采用(线性)汇编对循环内非个别语句做优化,由于本人汇编水平也比较懒,这里就不介绍了,向汇编高手们学习!
以上就是大嘴主要采用的方法,篇幅有限,实在无法更具体的展开介绍,以后大嘴会慢慢详细介绍,敬请关注,同时如果朋友还有什么更好的DSP移植优化方法,希望和大嘴交流,互相学习、共同进步
三、C6XX优化经验总结
一、c6x的编译的常用选项
(一)c6x的编译程序为“cl6x.exe”使用的方法
Cl6x [options] [filenames]
Cl6x: 编译程序
Options: 编译选项
Filenames: C或汇编源文件
说明:
编译选项是一个字母或者两个字母,对大小写不敏感。
编译选项的前面需要有一个“-”符号。
一个字母的选项可以合并在一起。比如“-sgq”与“-s -g -q”相同。
两个字母的选项如果第一个字母相同也可以合并在一起。比如“-mgt”与“-mg -mt”相同。
(二)有关优化的选项
-mt:表示在程序中没有使用alaising技术,这使得编译器可以进行比较好的优化。
-o3:对文件级别进行最强的优化,一般在编译时应该使用这个选项。但是在个别情况下使用这个选项优化程序可能会出现
错误(-o2有相同现象,-o0和-o1不会出现错误)。可能是在优化循环,组织流水线的时候发生错误。如果有这种现象出现可以同时
使用-g选项,程序优化就不会出现错误,但是优化效果会下降。另外可以调整程序的表达方式,可能会避免编译器发生错误。
-pm:在程序级别进行优化。可以将所以文件联合在一起进行优化,主要有去掉没有被调用的函数、总是常数的变量以及没有使用的
函数返回值。建议由程序员自己进行这种优化工作。使用这个选项在win98下编译可能会出现找不到编译程序的情况。
-ms0:不使用冗余循环进行优化,减小程序的大小。一般情况下这个选项对程序大小的优化作用不明显。
-mh[n]:去掉流水线的epilog,减小程序的大小。这个选项的作用比较明显。但是有可能出现读取地址超出有效范围的问题,
所以要在数据段的开始和结尾处增加一些pading,或者在分配内存时保证数组的前面和后面一段范围内都是有效的地址。
可选的参数n给出这种pading的长度字节数。
(三)保留编译和优化信息的选项
-k:保留优化后生成汇编语言文件。
-s:汇编语言文件中加入优化信息,如果没有则加入C语言源程序作为注释。
-mw:在汇编语言文件加入软件流水线信息。
(四)有关调试和剖析的选项
-g:允许符号调试,在“out”文件中包含符号信息和行号信息,可以在c语言级别进行调试和剖析。使用联合使用-g、-mt和-o3可以保
证能够进行符号调试的情况下最大限度的优化。
-mg:允许profile优化后的程序。 在“out”文件中包含符号信息和很少的行号信息。允许在c语言的函数基本进行剖析。
如果联合使用这两个选项,-g选项可能被忽略,结果与只用-mg相同。
(五)其它类型
-mln:生成大内存模式的程序。
-ml0:缺省情况下将集合变量(数组和结构)作为far型。
-ml1:缺省情况下将全部函数作为far型
-ml2: 等于-ml0加-ml1
-ml3: 缺省情况下将全部数据和函数作为far型
(六)建议使用的编译方式
Cl6x -gk -mt -o3 -mw -ss “filename”
方式1用于程序的调试,这种方式具有比较强的优化能力,并且支持符号调试。在编译的过程中不会发生错误。
由于生成的“out”文件中包含了符号信息和行号信息,所以比较大。
Cl6x -k -mgt -o3 -mw -ss “filename”
方式2用于程序的剖析(profile),这种方式的优化能力几乎最强(绝大多数情况下与方式3相同),
并且支持对程序进行profile。文件中只包含了符号信息和很少的行号信息,所以“out”文件比较小。
Cl6x -k -mt -o3 -mw -ss “filename”
方式3用于最终的发行版本程序,可以对程序进行最强的优化,并且去掉了全部的符号和行号信息,所以“out”文件比较小。
由多个文件组成的程序应该编写makefile,将编译参数放在该文件中,并在其中说明使用的编译器的版本号。
(七)连接参数
-heap:指定堆的大小
-stack: 指定栈的大小
连接的各种选项应该统一放在“cmd”文件中
二、双重循环和多重循环的优化总结
双重循环多重循环看起来比较复杂,但实际上多重循环优化方法比较简单,就在于一个字:“拆”,一旦完成这一步之后,
多重循环就成为单层循环,优化就可以按照普通的单层循环来做了。
多重循环的特点是在优化器优化时只在最内层循环中形成一个pipeline,这样循环语句就不能充分利用C6的软件流水线,
而且对于内部循环的次数较少的情况,消耗在prolog和eplog上的cycle数也是不可忽视的。
针对这种状况可以考虑将多重循环拆开形成一个单层循环,可以拆外层循环也可以拆内层循环,
一般视具体情况而定。这样就可以充分利用优化器构成的Pipeline。如下例:
void fir2(const short input[], const short coefs[], short out[])
{
int i, j;
int sum = 0;
for (i = 0; i < 40; i++)
{
for (j = 0; j < 16; j++)
sum += coefs[j] * input[i + 15 – j];
out[i] = (sum >> 15);
}
内层循环循环次数较少,运算量也不大,资源方面只占用了一个乘法器,一个cycle只使用一次乘法器,
而事实上我们可以在一个cycle内使用两个乘法器,所以还可以充分利用另外的一个乘法器。因此考虑将内层循环拆开来执行,如下:
void fir2_u(const short input[], const short coefs[], short out[])
{
int i, j;
int sum;
for (i = 0; i < 40; i++)
{
sum = coefs[0] * input[i + 15];
sum += coefs[1] * input[i + 14];
sum += coefs[2] * input[i + 13];
sum += coefs[3] * input[i + 12];
sum += coefs[4] * input[i + 11];
sum += coefs[5] * input[i + 10];
sum += coefs[6] * input[i + 9];
sum += coefs[7] * input[i + 8];
sum += coefs[8] * input[i + 7];
sum += coefs[9] * input[i + 6];
sum += coefs[10] * input[i + 5];
sum += coefs[11] * input[i + 4];
sum += coefs[12] * input[i + 3];
sum += coefs[13] * input[i + 2];
sum += coefs[14] * input[i + 1];
sum += coefs[15] * input[i + 0];
out[i] = (sum >> 15);
}
这样虽然代码长度增加了,可变成了单循环,所有的运算都参加到pipeline中来,在Piped loop kernal
中产生每一个cycle内都使用了两个乘法器,充分利用了DSP内部的资源,提高了运行效率。又如下例:
tot = 4;
for (k = 0; k < 4; k++)
{
max = 0;
for (i = k; i < 44; i += STEP)
{
s = 0;
for (j = i; j < 44; j++)
s = L_mac(s, x[j], h[j – i]);
y32[i] = s;
s = L_abs(s);
if (L_sub(s, max) > (Word32) 0)
max = s;
}
tot = L_add(tot, L_shr(max, 1));
}在这个多层循环中一共有三层循环,而最内层的循环的运算量很小,只有一次乘累加操作,
而我们知道C6中一个packet中可以做两个乘累加运算,所以为了增加内部循环的运算,减少外部循环的层数,
我们可以将第一层循环的操作拆开,其负责的运算加入到内部循环中,也就是在内层循环中一次做四次的乘累加运算,
这样将多次操作形成pipeline,提高了运行效率,优化后的C代码如下:
tot = 4;
max0=0;
max1=0;
max2=0;
max3=0;
for (i = 0; i <44; i += STEP) //STEP=4, 11 times cirs
{
//code
for (j=0;j<=40-i;j++)
{s0=(Word32)(_sadd(s0,_smpy(hh[j],xx[j+i])));
s1=(Word32)(_sadd(s1,_smpy(hh[j],xx[j+i+1])));
s2=(Word32)(_sadd(s2,_smpy(hh[j],xx[j+i+2])));
s3=(Word32)(_sadd(s3,_smpy(hh[j],xx[j+i+3])));
}
}
CCS的优化:
三、16位变为32位操作,使用intrinsic函数,用const等。
1、源代码:
Word32 L_mpy_ll(Word32 L_var1, Word32 L_var2)
{
double aReg;
Word32 lvar;
/* (unsigned)low1 * (unsigned)low1 */
aReg = (double)(0xffff & L_var1) * (double)(0xffff & L_var2) * 2.0;
/* >> 16 */
aReg = (aReg / 65536);
aReg = floor(aReg);
/* (unsigned)low1 * (signed)high2 */
aReg += (double)(0xffff & L_var1) * ((double)L_shr(L_var2,16)) * 2.0;
/* (unsigned)low2 * (signed)high1 */
aReg += (double)(0xffff & L_var2) * ((double)L_shr(L_var1,16)) * 2.0;
/* >> 16 */
aReg = (aReg / 65536);
aReg = floor(aReg);
/* (signed)high1 * (signed)high2 */
aReg += (double)(L_shr(L_var1,16)) * (double)(L_shr(L_var2,16)) * 2.0;
/* saturate result.. */
lvar = L_saturate(aReg);
return(lvar);
}
2、改编后的代码:
static inline Word32 L_mpy_ll(Word32 L_var1, Word32 L_var2)
{
Word32 aReg_hh;
Word40 aReg,aReg_ll,aReg_lh,aReg_hl;aReg_ll = (Word40)_mpyu(L_var1, L_var2)>>16;
aReg_lh = (Word40)_mpyluhs(L_var1, L_var2);
aReg_hl = (Word40)_mpyhslu(L_var1, L_var2);
aReg_hh = _smpyh(L_var1, L_var2);
aReg = _lsadd(aReg_ll, _lsadd(aReg_lh, aReg_hl));
aReg = _lsadd(aReg>>15, aReg_hh);return(_sat(aReg));
}
3、优化方法说明:
C6000编译器提供的intrinsic 可快速优化C代码,intrinsic用前下划线表示同调用函数一样可以调用它,即直接内联为C6000的函数。
例如,在上例的源代码中没有使用intrinsics,每一行C代码需多个指令周期,在改编后的代码中,每一行代码仅需一个指令周期。
例如,
“aReg_ll = (Word40)_mpyu(L_var1, L_var2)>>16”中“_mpyu”就是一个intrinsics函数,它表示两个无符号数的高16位相乘,
结果返回。C6000支持的所有intrinsics指令及其功能参见《TMS320C6000系列DSP的原理与应用》一书的第265、266页,
该书还提供了另外的例子。这些内联函数定义在CCS所在的C6000/CGTOOLS/Include目录下的C6X.h文件中。
下面这个例子是C6000的“Programmer’s Guide”上提取的使用intrinsics优化C代码的例子。
源代码:
int dotprod(const short *a, const short *b, unsigned int N)
{
int i, sum = 0;for (i = 0; i < N; i++)
sum += a[i] * b[i];
return sum;
}
改编后代码:
int dotprod(const int *a, const int *b, unsigned int N)
{
int i, sum1 = 0, sum2 = 0;for (i = 0; i < (N >> 1); i++)
{
sum1 += _mpy (a[i], b[i]);
sum2 += _mpyh(a[i], b[i]);
}
return sum1 + sum2;
}
技巧:
在C语言的调试全部通过以后,可以尝试将尽可能多的语句使用intrinsics函数加以改编,
尤其在循环体内,这种改编可以大幅度减少执行时间。
四、
1、源代码:
void fir_fxd1(short input[], short coefs[], short out[])
{
int i, j;
for (i = 0; i < 40; i++)
{
for (j = 0; j < 16; j++)
out[i*16+j]= coefs[j] * input[i + 15 – j];
}
}
2、改编后的代码:
void fir_fxd2(const short input[], const short coefs[], short out[])
{
int i, j;for (i = 0; i < 40; i++)
{
for (j = 0; j < 16; j++)
out[i*16+j]= coefs[j] * input[i + 15 – j];
}
3、优化方法说明:
C6000编译器如果确定两条指令是不相关的,则安排它们并行执行。 关键字const可以指定一个变量或者一个变量的存储单元保持不变。
这有助于帮助编译器确定指令的不相关性。例如上例中,源代码不能并行执行,而结果改编后的代码可以并行执行。
4、技巧:
使用const可以限定目标,确定存在于循环迭代中的存储器的不相关性。
五、
1、源代码:
void vecsum(short *sum, short *in1, short *in2, unsigned int N)
{
int i;for (i = 0; i < N; i++)
sum[i] = in1[i] + in2[i];
}
2、改编后的代码:
void vecsum6(int *sum, const int *in1, const int *in2, unsigned int N)
{
int i;
int sz = N >> 2;_nassert(N >= 20);
for (i = 0; i < sz; i += 2)
{
sum[i] = _add2(in1[i] , in2[i]);
sum[i+1] = _add2(in1[i+1], in2[i+1]);
}
}
3、优化方法说明:
源代码中,函数变量的定义是 short *sum, short *in1, short *in2, 改编后的代码函数变量是
int *sum, const int *in1, const int *in2, 整数类型由16位改编成32位,这时使用内联指令“_add2”一次可以完成两组16位整数的
加法, 效率提高一倍。注意这里还使用了关键字const和内联指令_nassert优化源代码。
4、技巧:
用内联指令_add2、_mpyhl、_mpylh完成两组16位数的加法和乘法,效率比单纯16位数的加法和乘法提高一倍。
六、if…else…语句的优化
(一)
1、源代码:
if (sub (ltpg, LTP_GAIN_THR1) <= 0)
{
adapt = 0;
}
else
{
if (sub (ltpg, LTP_GAIN_THR2) <= 0)
{
adapt = 1;
}
else
{
adapt = 2;
}
}
2、改编后的代码:
adapt = (ltpg>LTP_GAIN_THR1) + (ltpg>LTP_GAIN_THR2);
(二)
1、源代码:
if (adapt == 0)
{
if (filt>5443)
{
result = 0;
}
else
{
if (filt < 0)
{
result = 16384;
}
else
{
filt = _sshl (filt, 18)>>16; // Q15
result = _ssub (16384, _smpy(24660, filt)>>16);
}
}
}
else
{
result = 0;
}
2、改编后的代码:
filt1 = _sshl (filt, 18)>>16;
tmp = _smpy(24660, filt1)>>16;
result = _ssub(16384, tmp * (filt>=0));
result = result * (!((adapt!=0)||(filt>5443)));
(三)
1、源代码:
static Word16 saturate(Word32 L_var1)
{
Word16 swOut;if (L_var1 > SW_MAX)
{
swOut = SW_MAX;
giOverflow = 1;
}
else if (L_var1 < SW_MIN)
{
swOut = SW_MIN;
giOverflow = 1;
}
else
swOut = (Word16) L_var1; /* automatic type conversion */
return (swOut);
}
2、改编后的代码:
static inline Word32 L_shl(Word32 a,Word16 b)
{
return ((Word32)((b) < 0 ? (Word32)(a) >> (-(b)) : _sshl((a),(b)))) ;
}
3、优化方法说明:
如果在循环中出现if…else…语句,由于if…else…语句中有跳转指令,而每个跳转指令有5个延迟间隙,
因此程序执行时间延长;另外,循环内跳转也使软件流水受到阻塞。直接使用逻辑判断语句可以去除不必要的跳转。
例如在例1的源代码最多有两次跳转,而改编后不存在跳转。例2和例3同样也去掉了跳转。
4、技巧:
尽可能地用逻辑判断语句替代if…else…语句,减少跳转语句。
七、
1、源程序
dm = 0x7FFF;
for (j = 0; j < nsiz[m]; j = add(j, 1))
{
if (d[j] <= dm)
{
dm = d[j];
jj = j;
}
}
index[m] = jj;
2、优化后的程序
dm0 = dm1 = 0x7fff;
d0 = (Word16 *)&d[0];
d1 = (Word16 *)&d[1];
# pragma MUST_ITERATE(32,256,64);
for (j = 0; j < Nsiz; j+=2)
{
n0 = *d0;
d0 += 2;
n1 = *d1;
d1 += 2;
if (n0 <= dm0)
{
dm0 = n0;
jj0 = j;
}
if (n1 <= dm1)
{
dm1 = n1;
jj1 = j+1;
}
}
if (dm1 != dm0)
{
index[m] = (dm1 < dm0)? jj1:jj0;
}
else
{
index[m] = (jj1 > jj0)? jj1:jj0;
}
3、优化说明
求数组的最小值程序,优化时为了提高程序效率在一个循环之内计算N=1,3,5..和n=2,4,6…的最小值,
然后在比较二者的大小以求得整个数组的最小值。
八、
1、源程序
for (k = 0; k < NB_PULSE; k++)
{
i = codvec[k];
j = sign[i];
index = mult(i, Q15_1_5);
track = sub(i, extract_l(L_shr(L_mult(index, 5), 1)));
if (j > 0)
{
if (i < l_subfr) code[i] = add(code[i], 4096);
codvec[k] += (2 * L_SUBFR);
}
else
{
if (i < l_subfr) code[i] = sub(code[i], 4096);
index = add(index, 16);
}
if (indx[track] < 0)
{
indx[track] = index;
}
else
{
if (((index ^ indx[track]) & 16) == 0)
{
if (sub(indx[track], index) <= 0)
{
indx[track] = shl((indx[track] & 16), 3)
+ shr(extract_l(L_mult((indx[track] & 15), NB_POS)), 1) + (index & 15);
}
else
{
indx[track] = shl((index & 16), 3)
+ shr(extract_l(L_mult((index & 15), NB_POS)), 1) + (indx[track] & 15);
}
}
else
{
if (sub((indx[track] & 15), (index & 15)) <= 0)
{
indx[track] = shl((index & 16), 3)
+ shr(extract_l(L_mult((index & 15), NB_POS)), 1) + (indx[track] & 15);
}
else
{
indx[track] = shl((indx[track] & 16), 3)
+ shr(extract_l(L_mult((indx[track] & 15), NB_POS)), 1) + (index & 15);
}
}
}
}
2、优化后的程序
for (k = 0; k < 8; k++)
{
i = codvec[k];
j = sign[i];
index = _smpy(i, 6554)>>16;
track = i – index*5;
con = (j > 0);
codvec[k] = codvec[k] + 110*con;
index = index + (!con)*16;
conn = (i < l_subfr);
cono = (j > 0)? 1:-1;
code[i] = code[i] + 4096*conn*cono;
n0 = index;
t0 = indx[track];
n1 = n0&16;
t1 = t0&16;
n2 = n0&15;
t2 = t0&15;
tmp0 = (_sshl(n1,19)>>16) + n2*NB_POS + t2;
tmp1 = (_sshl(t1,19)>>16) + t2*NB_POS + n2;
conp = (((n1 == t1)&&(t0 > n0))||((n1 != t1)&&(t2 <= n2)));
tmp = conp*tmp0 + (!conp)*tmp1;
if (t0 < 0)
indx[track] = n0;
else
indx[track] = tmp;
}
3、优化说明
源程序中在循环中含有许多的if结构,在优化时对if结构首先进行化简,
再将化简后的if结构用条件运算表达式进行改写,最后使循环可以Pipeline。
九、
1、源程序
for (i = 0; i < n; i++)
{
max = -32767;
for (j = 0; j < n; j++)
{
if (sub (tmp2[j], max) >= 0)
{
max = tmp2[j];
ix = j;
}
}
tmp2[ix] = -32768;
tmp[i] = ix;
}
2、优化后的程序
if (n0>n1) {temp=n0;n0=n1;n1=temp;}
if (n1>n2) {temp=n1;n1=n2;n2=temp;}
if (n2>n3) {temp=n2;n2=n3;n3=temp;}
if (n3>n4) {temp=n3;n3=n4;n4=temp;}
if (n0>n1) {temp=n0;n0=n1;n1=temp;}
if (n1>n2) {temp=n1;n1=n2;n2=temp;}
if (n2>n3) {temp=n2;n2=n3;n3=temp;}
if (n0>n1) {temp=n0;n0=n1;n1=temp;}
if (n1>n2) {return n1;}
3、优化说明
源程序也为一个求中值的问题,由于已知循环次数固定为5,因此将循环展开使用if语句直接求取中值。
十、
1、源程序
static Word16 Bin2int (Word16 no_of_bits, Word16 *bitstream)
{
Word16 value, i, bit;value = 0;
for (i = 0; i < no_of_bits; i++)
{
value = shl (value, 1);
bit = *bitstream++;
if (sub (bit, BIT_1) == 0)
value = add (value, 1);
}
return (value);
}for (i = 0; i < prmno[mode]; i++)
{
prm[i] = Bin2int (bitno[mode][i], bits);
bits += bitno[mode][i];
}
2、优化后的程序
value = 0;
bitsp = bits;
bitnop= &bitno[mode][0];
j = *bitnop++;
j1 = *bitnop++;
j2 = *bitnop++;
j3 = *bitnop++;
j4 = *bitnop++;
_nassert(loop[mode]>=35);
for (i = 0; i < loop[mode]; i++)
{
value = value*2 + *bitsp++;
j–;
if (j == 0)
{
*prm++ = value;
value = 0;
j = j1;
j1 = j2;
j2 = j3;
j3 = j4;
j4 = *bitnop++;
}
}
3、优化说明
源程序按照数据位流定义取出参数,为双重循环结构,优化中采用重新根据位流的bit长度定义循环次数,
化简为单重循环,然后优化循环,去除boundary,使pipeline的数目最小。
十一、copy程序的优化
1、源代码:
Word16 i;
for (i = 0; i < L; i++)
{
y[i] = x[i];
}
2、改编代码:
(1)要求数组长度能被2整除
Word32 i;
Word32 temp;
int *p1 = (int *)&x[0];
int *q1 = (int *)&y[0];
for (i = 0; i < L/2; i++)
{
temp = *p1++;
*q1++ = temp;
}
(2)要求数组长度能被4整除
Word32 i;
Word32 temp1, temp2;
Word32 *pin1, *pin2, *pout1, *pout2;
pin1 = (Word32 *)&x[0];
pin2 = (Word32 *)&x[2];
pout1= (Word32 *)&y[0];
pout2= (Word32 *)&y[2];
for (i = 0; i < L/4; i++)
{
temp1 = *pin1;
temp2 = *pin2;
pin1+=2;
pin2+=2;
*pout1= temp1;
*pout2= temp2;
pout1+=2;
pout2+=2;
}
3、优化方法说明:
把一次循环拷贝一个word16的数改为一次循环拷贝2个word16或4个word16的数。
4、技巧:
充分利用c6xx一次读取32位数的特性,并利用一个指令周期能读取两个数据的特点。
十二、set_zero程序的优化
1、源代码:
Word16 i;
for (i = 0; i < L; i++)
{
x[i] = 0;
}
2、改编代码:
(1)数组长度能被2整除
Word32 i;
int *x1 = (int *)&x[0];
for (i = 0; i < L/2; i++)
{
*x1++ = 0;
}
(2)数组长度能被4整除
Word32 i;
int *x1 = (int *)&x[0];
int *x2 = (int *)&x[2];
for (i = 0; i < L/4; i++)
{
*x1 = 0;
*x2 = 0;
x1++;
x2++;
x1++;
x2++;
}
3、优化方法说明:
把一次循环为一个word16的数赋值改为一次为2个或4个word16的数赋值。
4、技巧:
充分利用C6XX一次读取32位数的特点,并利用一个指令周期能读取两个数据的特点。
十三、32bit数与16bit数相乘
1、源代码:
L_tmp0 = Mac_32_16(L_32, hi1, lo1, lo2);
2、改编代码:
L_tmp0=_sadd(_sadd(_smpyhl(hl32, lo2),
(_mpyus(hl32, lo2)>>16)<<1), L_32);
3、优化方法说明:
hl32是32bit的数,hi1和lo1是16bit的数,且 hl32 = hi 1<<16 + lo1 << 1 ,即hi1和lo1分别是hl32的高16位数和低16位数。
函数Mac_32_16(L_32, hi1, lo1, lo2)实现
L_32 = L_32 + (hi1*lo2)<<1 + ((lo1*lo2)>>15)<<1
源代码是把一个32位的数拆成两个16位的数与一个16位的数相乘,优化后的代码不拆开32位的数,
直接用32位的数与16位的数相乘。运用这种方法必须保证hl32的最低一位数必须为0,否则应用指令_clr(hl32, 0, 0)把
最低位清零。
4、技巧:
源代码中的低16位数lo1是hl32的低16位右移一位得到的(留出一位符号位)。在与lo2相乘时又右移了15位,
所以在改编代码中右移16位,并且是以无符号数与lo2相乘。
十四、32bit数与32bit数相乘
1、源代码:
L_tmp = Mac_32 (L_32, hi1, lo1, hi2, lo2);
2、改编代码:
L_tmp = _sadd(_sadd(_smpyh(hl1_32, hl2_32),
((_mpyhslu(hl1_32, hl2_32)>>16)<<1)+
((_mpyhslu(hl2_32, hl1_32)>>16)<<1)), L_32);
3、优化方法说明:
两个32位的数相乘,不必分成四个16位的数相乘,直接用32位相乘。其中:
hl1_32 = hi1<<16 + lo1<<1, hl2_32 = hi2 <<16 + lo2 <<1 。
源代码实现: L_32 = L_32 + (hi1*hi2)<<1 + ( (hi1*lo2)>>15 + (lo1*hi2)>>15 )<<1
4、技巧:
低16位与高16位相乘时,低16位使用的是无符号数。
十五、16位除法的优化
1、源代码:
Word16 div_s (Word16 var1, Word16 var2) //实现 var1/var2
{
Word16 var_out = 0;
Word16 iteration;
Word32 L_num = (Word32)var1;
Word32 L_denom = (Word32)var2;
for (iteration = 0; iteration < 15; iteration++)
{
var_out <<= 1;
L_num <<= 1;
if (L_num >= L_denom)
{
L_num = L_sub (L_num, L_denom);
var_out = add (var_out, 1);
}
}
return (var_out);
}
2、改编代码:
Word16 div_s1 (Word16 var1, Word16 var2)
{
Word32 var1int;
Word32 var2int;
var1int = var1 << 16;
var2int = var2 << 15;
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
var1int = _subc(var1int,var2int);
return (var1int & 0xffff);
}
3、优化方法说明:
实现16位的除法,要求被除数var1和除数var2都是整数,且var1<=var2。利用C6XX特有的指令subc,实现除法的循环移位相减操作。
4、技巧:
把被除数和除数都转换成32位数来操作,返回时取低16位数。
十六、C6X优化inline举例:
1、原程序:
for (i = LO_CHAN; i <= HI_CHAN; i++)
{norm_shift = norm_l(st->ch_noise[i]);
Ltmp = L_shl(st->ch_noise[i], norm_shift);norm_shift1 = norm_l(st->ch_enrg[i]);
Ltmp3 = L_shl1(st->ch_enrg[i], norm_shift1 – 1);Ltmp2 = L_divide(Ltmp3, Ltmp);
Ltmp2 = L_shr(Ltmp2, 27 – 1 + norm_shift1 – norm_shift); // * scaled as 27,4 *if (Ltmp2 == 0)
Ltmp2 = 1;Ltmp1 = fnLog10(Ltmp2);
Ltmp3 = L_add(Ltmp1, LOG_OFFSET – 80807124); // * -round(log10(2^4)*2^26 *
Ltmp2 = L_mult(TEN_S5_10, extract_h(Ltmp3));
if (Ltmp2 < 0)
Ltmp2 = 0;
// * 0.1875 scaled as 10,21 *
Ltmp1 = L_add(Ltmp2, CONST_0_1875_S10_21);
// * tmp / 0.375 2.667 scaled as 5,10, Ltmp is scaled 15,16 *
Ltmp = L_mult(extract_h(Ltmp1), CONST_2_667_S5_10);
ch_snr[i] = extract_h(Ltmp);
}
*/
2、优化后程序:
//因循环体太大,拆成两个循环并把相应的函数内嵌以使程序能pipeline,
//用L_div_tmp[]保存因拆分而产生的中间变量。
for (i = LO_CHAN; i <= HI_CHAN; i++)
{
//norm_shift = norm_l(st->ch_noise[i]);
norm_shift = _norm(st->ch_noise[i]);
Ltmp = _sshl(st->ch_noise[i], norm_shift);//norm_shift1 = norm_l(st->ch_enrg[i]);
norm_shift1 = _norm(st->ch_enrg[i]);
//Ltmp3 = L_shl1(st->ch_enrg[i], norm_shift1 – 1);
LLtmp1 = st->ch_enrg[i];
LLtmp1 = LLtmp1 << (norm_shift1 + 7);
Ltmp3 = (Word32)(LLtmp1 >> 8);Ltmp2 = IL_divide(Ltmp3, Ltmp);
//Ltmp2 = L_shr(Ltmp2, 27 – 1 + norm_shift1 – norm_shift);
Ltmp2 = (Ltmp2 >> (27 – 1 + norm_shift1 – norm_shift));if (Ltmp2 == 0)
Ltmp2 = 1;
L_div_tmp[i] = Ltmp2;
}
for (i = LO_CHAN; i <= HI_CHAN; i++)
{
Ltmp2 = L_div_tmp[i];
Ltmp1 = IfnLog10(Ltmp2);
//Ltmp3 = L_add(Ltmp1, LOG_OFFSET – 80807124);
Ltmp3 = _sadd(Ltmp1, LOG_OFFSET – 80807124);
//Ltmp2 = L_mult(TEN_S5_10, extract_h(Ltmp3));
Ltmp2 = _smpy(TEN_S5_10, (Ltmp3 >> 16));
if (Ltmp2 < 0)
Ltmp2 = 0;Ltmp1 = _sadd(Ltmp2, CONST_0_1875_S10_21);
//Ltmp = L_mult(extract_h(Ltmp1), CONST_2_667_S5_10);
Ltmp = _smpy((Ltmp1 >> 16), CONST_2_667_S5_10);
//ch_snr[i] = extract_h(Ltmp);
ch_snr[i] = (Ltmp >> 16);
}
3、优化说明
观察上面这个循环,循环体本身比较大,且含有两个函数L_divide()和
fnLog10(),而C62内部只有32个寄存器,且有些寄存器是系统用的,如B14、B15这样循环体太大将会导致寄存器不够分配,
从而导致系统编译器无法实现循环的pipeline。
为了实现循环的pipeline。我们需要把循环体进行拆分,拆分时要考虑以下几点:
(1)、拆分成几个循环比较合适?在各个循环能pipeline的前提下,拆开的循环个数越少越好。这就要求尽可能让各个
循环的运算量接近。
(2)考虑在什么地方把程序拆开比较合适?循环体里的数据流往往并不是单一的,在拆开的断点处势必要用中间变量保
存上次的循环运算结果,供以后的循环用。适当的拆开循环体,使所需的中间变量越少越好。
(3)循环体中的函数调用必须定义成内嵌形式,含有函数调用的循环系统是无法使之pipeline的;各个循环体中的判断分支
机构不可太多,否则系统也无法使之pipeline,为此应近可能把可以确定下来的分支确定下来,并尽可能用内嵌指令。
针对上面这个例子,考虑:
(1)为让各个循环的运算量大致相当,应把L_divide()和fnLog10()分到两个循环中去,从循环体大小上考虑,
估计拆成两个循环比较合适。
(2)考虑在什么地方把程序拆开比较合适?在
if (Ltmp2 == 0)
Ltmp2 = 1;
后拆开,因为后面用到的数据只有Ltmp2,故只需用一个数组保存每次循环的Ltmp2值即可。
(3)循环体中的两处函数调用L_divide()和fnLog10()都定义了其内嵌形式,IL_divide()和IfnLog10()。
当把可以确定下来的分支作确定处理,并尽可能用内嵌指令后,该循环体中所剩的分支结构已很少,循环体可以pipeline。
优化前程序用2676 cycle,优化后用400 cycle。优化后两个子循环的MII分别为14和6cycle。
内存地址形式: 奔腾,C6000都是32位计算机,字长32,但内存地址都是按字节组织的 一个字4字节(查看内存时候各个字
时候:例如两个连续字ox1000 ox1004) 写汇编程序时候,下一个字也需要+4,但写 C语言时候,int 型,+1就是加4
但是,在Tiger SHARC中,虽然也是32位机,但内存是地址是按字组织的,查看内存时,连续的字地址相差1
#include <stdio.h>
#define INTRINSIC
short add(short var1,short var2)
{
short var_out;
int L_somme;
L_somme = (int) var1 + var2;
return(var_out);
}int main()
{
int i,result;
#ifdef INTRINSIC
for(i=0; i<1000;i++)
{
result=_sadd(100000,20);
result>0X00007fff?result=0x7fff:(result<0x8000?result=0x8000:0);
}
#else
for(i=0;i<1000;i++)
add(10,20);
#endif
return 0;
}